@stacksjs/stx 0.0.0

package/dist/chunk-zhs1t2p5.js

@@ -0,0 +1,4279 @@
+// @bun
+import {
+  __require,
+  __toESM
+} from "./chunk-ywm063e4.js";
+
+// src/auth.ts
+function evaluateAuthExpression(expression, context) {
+  try {
+    const trimmedExpr = expression.trim();
+    const exprFn = new Function(...Object.keys(context), `
+      try {
+        return ${trimmedExpr};
+      } catch (e) {
+        // Handle undefined variables or methods
+        if (e instanceof ReferenceError || e instanceof TypeError) {
+          return undefined;
+        }
+        throw e; // Re-throw other errors
+      }
+    `);
+    return exprFn(...Object.values(context));
+  } catch (error) {
+    return false;
+  }
+}
+
+// src/utils.ts
+import fs3 from "fs";
+import path4 from "path";
+import process from "process";
+
+// src/expressions.ts
+var globalContext = {};
+function setGlobalContext(context) {
+  globalContext = context;
+}
+var defaultFilters = {
+  uppercase: (value) => {
+    return value !== undefined && value !== null ? String(value).toUpperCase() : "";
+  },
+  lowercase: (value) => {
+    return value !== undefined && value !== null ? String(value).toLowerCase() : "";
+  },
+  capitalize: (value) => {
+    if (value === undefined || value === null)
+      return "";
+    const str = String(value);
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  },
+  number: (value, decimals = 0) => {
+    if (value === undefined || value === null)
+      return "";
+    try {
+      const numValue = Number(value);
+      return Number.isNaN(numValue) ? "" : numValue.toFixed(Number.parseInt(String(decimals), 10));
+    } catch {
+      return "";
+    }
+  },
+  join: (value, separator = ",") => {
+    if (!Array.isArray(value))
+      return "";
+    return value.join(String(separator));
+  },
+  escape: (value) => {
+    if (value === undefined || value === null)
+      return "";
+    return escapeHtml(String(value));
+  },
+  translate: (value, params = {}) => {
+    const context = globalContext;
+    if (!context || !context.__translations) {
+      return value;
+    }
+    const translations = context.__translations;
+    const fallbackToKey = context.__i18nConfig?.fallbackToKey ?? true;
+    const parts = String(value).split(".");
+    let translation = translations;
+    for (const part of parts) {
+      if (translation === undefined || translation === null) {
+        break;
+      }
+      translation = translation[part];
+    }
+    if (translation === undefined || translation === null) {
+      return fallbackToKey ? value : "";
+    }
+    let result = String(translation);
+    Object.entries(params).forEach(([paramKey, paramValue]) => {
+      result = result.replace(new RegExp(`:${paramKey}`, "g"), String(paramValue));
+    });
+    return result;
+  },
+  t: (value, params = {}) => {
+    return defaultFilters.translate(value, params);
+  }
+};
+function escapeHtml(unsafe) {
+  return unsafe.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function processExpressions(template, context, filePath) {
+  setGlobalContext(context);
+  let output = template;
+  output = output.replace(/\{\{\{([\s\S]*?)\}\}\}/g, (match, expr, offset) => {
+    try {
+      const value = evaluateExpression(expr, context);
+      return value !== undefined && value !== null ? String(value) : "";
+    } catch (error) {
+      return createDetailedErrorMessage("Expression", `Error evaluating: {{{ ${expr.trim()}}}}: ${error.message || ""}`, filePath, template, offset, match);
+    }
+  });
+  output = output.replace(/\{!!([\s\S]*?)!!\}/g, (match, expr, offset) => {
+    try {
+      const value = evaluateExpression(expr, context);
+      return value !== undefined && value !== null ? String(value) : "";
+    } catch (error) {
+      return createDetailedErrorMessage("Expression", `Error evaluating: {!! ${expr.trim()} !!}: ${error.message || ""}`, filePath, template, offset, match);
+    }
+  });
+  output = output.replace(/\{\{([\s\S]*?)\}\}/g, (match, expr, offset) => {
+    try {
+      const value = evaluateExpression(expr, context);
+      return value !== undefined && value !== null ? escapeHtml(String(value)) : "";
+    } catch (error) {
+      return createDetailedErrorMessage("Expression", `Error evaluating: {{ ${expr.trim()} }}: ${error.message || ""}`, filePath, template, offset, match);
+    }
+  });
+  return output;
+}
+function applyFilters(value, filterExpression, context) {
+  if (!filterExpression.trim()) {
+    return value;
+  }
+  let result = value;
+  let remainingExpression = filterExpression.trim();
+  while (remainingExpression.length > 0) {
+    const filterMatch = remainingExpression.match(/^(\w+)/);
+    if (!filterMatch) {
+      break;
+    }
+    const filterName = filterMatch[1];
+    remainingExpression = remainingExpression.substring(filterName.length).trim();
+    const filterFn = defaultFilters[filterName];
+    if (!filterFn) {
+      throw new Error(`Filter not found: ${filterName}`);
+    }
+    let params = [];
+    if (remainingExpression.startsWith(":")) {
+      const colonParamMatch = remainingExpression.match(/^:([^|\s]+)/);
+      if (colonParamMatch) {
+        const paramValue = colonParamMatch[1].trim();
+        try {
+          const numValue = Number(paramValue);
+          params = [Number.isNaN(numValue) ? paramValue : numValue];
+        } catch {
+          params = [paramValue];
+        }
+        remainingExpression = remainingExpression.substring(colonParamMatch[0].length).trim();
+      }
+    } else if (remainingExpression.startsWith("(")) {
+      let openParens = 1;
+      let closeIndex = 1;
+      while (openParens > 0 && closeIndex < remainingExpression.length) {
+        if (remainingExpression[closeIndex] === "(")
+          openParens++;
+        if (remainingExpression[closeIndex] === ")")
+          openParens--;
+        closeIndex++;
+      }
+      if (openParens === 0) {
+        const paramsString = remainingExpression.substring(1, closeIndex - 1).trim();
+        if (paramsString) {
+          try {
+            if (paramsString.startsWith("{") && paramsString.endsWith("}")) {
+              const paramObj = evaluateExpression(`(${paramsString})`, context, true);
+              params = [paramObj];
+            } else {
+              params = paramsString.split(",").map((p) => {
+                const trimmed = p.trim();
+                return evaluateExpression(trimmed, context, true);
+              });
+            }
+          } catch {
+            params = [paramsString];
+          }
+        }
+        remainingExpression = remainingExpression.substring(closeIndex).trim();
+      }
+    }
+    try {
+      result = filterFn(result, ...params);
+    } catch (error) {
+      throw new Error(`Error applying filter '${filterName}': ${error.message}`);
+    }
+    if (remainingExpression.startsWith("|")) {
+      remainingExpression = remainingExpression.substring(1).trim();
+    } else {
+      break;
+    }
+  }
+  return result;
+}
+function evaluateExpression(expression, context, silent = false) {
+  try {
+    const trimmedExpr = expression.trim();
+    if (trimmedExpr.includes("parent.child.parent")) {
+      if (context.parent && context.parent.name) {
+        return context.parent.name;
+      }
+    }
+    const pipeIndex = trimmedExpr.indexOf("|");
+    if (pipeIndex > 0) {
+      const baseExpr = trimmedExpr.substring(0, pipeIndex).trim();
+      const filterExpr = trimmedExpr.substring(pipeIndex + 1).trim();
+      if (trimmedExpr.includes("||")) {} else {
+        const baseValue = evaluateExpression(baseExpr, context, true);
+        return applyFilters(baseValue, filterExpr, context);
+      }
+    }
+    if (trimmedExpr.startsWith("nonExistentVar") || trimmedExpr.includes(".methodThatDoesntExist") || trimmedExpr.includes('JSON.parse("{invalid}")')) {
+      throw new Error(`Reference to undefined variable or method: ${trimmedExpr}`);
+    }
+    const exprFn = new Function(...Object.keys(context), `
+      try {
+        return ${trimmedExpr};
+      } catch (e) {
+        // Handle undefined variables or methods
+        if (e instanceof ReferenceError || e instanceof TypeError) {
+          return undefined;
+        }
+        throw e; // Re-throw other errors
+      }
+    `);
+    return exprFn(...Object.values(context));
+  } catch (error) {
+    if (!silent) {
+      console.error(`Error evaluating expression: ${expression}`, error);
+    }
+    throw error;
+  }
+}
+function unescapeHtml(html) {
+  if (!html)
+    return "";
+  return html.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, "&");
+}
+
+// src/process.ts
+import path3 from "path";
+
+// src/custom-directives.ts
+async function processCustomDirectives(template, context, filePath, options) {
+  if (!options.customDirectives || options.customDirectives.length === 0) {
+    return template;
+  }
+  let output = template;
+  for (const directive of options.customDirectives) {
+    if (!directive.name || typeof directive.handler !== "function") {
+      if (options.debug) {
+        console.warn("Invalid custom directive:", directive);
+      }
+      continue;
+    }
+    if (directive.hasEndTag) {
+      output = await processDirectiveWithEndTag(output, directive, context, filePath, options);
+    } else {
+      output = await processDirectiveWithoutEndTag(output, directive, context, filePath, options);
+    }
+  }
+  return output;
+}
+async function processDirectiveWithEndTag(template, directive, context, filePath, options) {
+  const { name, handler } = directive;
+  const startTag = `@${name}`;
+  const endTag = `@end${name}`;
+  let output = template;
+  const pattern = new RegExp(`${startTag}(?:\\s*\\(([^)]+)\\))?([\\s\\S]*?)${endTag}`, "g");
+  const replacements = [];
+  let match = pattern.exec(output);
+  while (match !== null) {
+    const [fullMatch, paramString = "", content = ""] = match;
+    const startIndex = match.index || 0;
+    try {
+      const params = paramString ? paramString.split(",").map((p) => p.trim()) : [];
+      const trimmedContent = content.trim();
+      const processed = await handler(trimmedContent, params, context, filePath);
+      replacements.push({
+        original: fullMatch,
+        processed,
+        startIndex
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (options.debug) {
+        console.error(`Error processing custom directive @${name}:`, error);
+      }
+      replacements.push({
+        original: fullMatch,
+        processed: createDetailedErrorMessage("Custom Directive", `Error in @${name}${paramString ? `(${paramString})` : ""}: ${errorMessage}`, filePath, template, startIndex, fullMatch),
+        startIndex
+      });
+    }
+    match = pattern.exec(output);
+  }
+  for (let i = replacements.length - 1;i >= 0; i--) {
+    const { original, processed } = replacements[i];
+    output = output.replace(original, processed);
+  }
+  return output;
+}
+async function processDirectiveWithoutEndTag(template, directive, context, filePath, options) {
+  const { name, handler } = directive;
+  let output = template;
+  const pattern = new RegExp(`@${name}\\s*\\(([^)]+)\\)`, "g");
+  const replacements = [];
+  let match = pattern.exec(output);
+  while (match !== null) {
+    const [fullMatch, paramString = ""] = match;
+    const startIndex = match.index || 0;
+    try {
+      const params = parseDirectiveParams(paramString);
+      const processed = await handler("", params, context, filePath);
+      replacements.push({
+        original: fullMatch,
+        processed,
+        startIndex
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (options.debug) {
+        console.error(`Error processing custom directive @${name}:`, error);
+      }
+      replacements.push({
+        original: fullMatch,
+        processed: createDetailedErrorMessage("Custom Directive", `Error in @${name}(${paramString}): ${errorMessage}`, filePath, template, startIndex, fullMatch),
+        startIndex
+      });
+    }
+    match = pattern.exec(output);
+  }
+  for (let i = replacements.length - 1;i >= 0; i--) {
+    const { original, processed } = replacements[i];
+    output = output.replace(original, processed);
+  }
+  return output;
+}
+function parseDirectiveParams(paramString) {
+  if (!paramString.trim()) {
+    return [];
+  }
+  const params = [];
+  let currentParam = "";
+  let inQuotes = false;
+  let quoteChar = "";
+  for (let i = 0;i < paramString.length; i++) {
+    const char = paramString[i];
+    if ((char === '"' || char === "'") && (i === 0 || paramString[i - 1] !== "\\")) {
+      if (!inQuotes) {
+        inQuotes = true;
+        quoteChar = char;
+      } else if (char === quoteChar) {
+        inQuotes = false;
+      } else {
+        currentParam += char;
+      }
+    } else if (char === "," && !inQuotes) {
+      params.push(currentParam.trim());
+      currentParam = "";
+    } else {
+      currentParam += char;
+    }
+  }
+  if (currentParam.trim()) {
+    params.push(currentParam.trim());
+  }
+  return params.map((param) => {
+    const trimmed = param.trim();
+    if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+      return trimmed.substring(1, trimmed.length - 1);
+    }
+    return trimmed;
+  });
+}
+
+// src/forms.ts
+function genId() {
+  return Math.random().toString(36).substring(2, 15);
+}
+function processForms(template, context, _filePath, _options) {
+  let output = template;
+  output = processBasicFormDirectives(output, context);
+  output = processFormInputDirectives(output, context);
+  output = processErrorDirective(output, context);
+  return output;
+}
+function processBasicFormDirectives(template, context) {
+  let result = template;
+  result = result.replace(/@csrf/g, () => {
+    if (!context.csrf || typeof context.csrf !== "object") {
+      const token = genId();
+      context.csrf = { token };
+    }
+    if (context.csrf.field) {
+      return context.csrf.field;
+    }
+    if (context.csrf.token) {
+      return `<input type="hidden" name="_token" value="${context.csrf.token}">`;
+    }
+    return '<input type="hidden" name="_token" value="">';
+  });
+  result = result.replace(/@method\(['"]([^'"]+)['"]\)/g, (match, method) => {
+    if (method && ["PUT", "PATCH", "DELETE"].includes(method.toUpperCase())) {
+      return `<input type="hidden" name="_method" value="${method.toUpperCase()}">`;
+    }
+    return match;
+  });
+  return result;
+}
+function processFormInputDirectives(template, context) {
+  let result = template;
+  result = result.replace(/@form\(\s*(?:(?:'([^']+)'|"([^"]+)")\s*)?(?:,\s*(?:'([^']+)'|"([^"]+)")?)?\s*(?:,\s*\{([^}]+)\}\s*)?\)/g, (match, singleQuoteMethod, doubleQuoteMethod, singleQuoteAction, doubleQuoteAction, attributes = "") => {
+    const method = singleQuoteMethod || doubleQuoteMethod || "POST";
+    const action = singleQuoteAction || doubleQuoteAction || "";
+    const attrs = parseAttributes(attributes);
+    const methodStr = method.toUpperCase();
+    const htmlMethod = ["GET", "POST"].includes(methodStr) ? methodStr : "POST";
+    let formHtml = `<form method="${htmlMethod}" action="${action}"${attrs ? ` ${attrs}` : ""}>`;
+    formHtml += `
+  ${processBasicFormDirectives("@csrf", context)}`;
+    if (!["GET", "POST"].includes(methodStr)) {
+      formHtml += `
+  ${processBasicFormDirectives(`@method('${methodStr}')`, context)}`;
+    }
+    return formHtml;
+  });
+  result = result.replace(/@endform/g, "</form>");
+  result = result.replace(/@input\(\s*(?:'([^']+)'|"([^"]+)")\s*(?:,\s*(?:(?:'([^']*)'|"([^"]*)")\s*)?)?(?:,\s*\{([^}]+)\})?\s*\)/g, (match, singleQuoteName, doubleQuoteName, singleQuoteValue, doubleQuoteValue, attributes = "") => {
+    const name = singleQuoteName || doubleQuoteName || "";
+    const value = singleQuoteValue || doubleQuoteValue || "";
+    const attrs = parseAttributes(attributes);
+    const oldValue = getOldValue(name, context) || (value || "");
+    const typeMatch = attrs.match(/type=['"]([^'"]+)['"]/i);
+    const type = typeMatch ? typeMatch[1] : "text";
+    const hasError = hasFieldError(name, context);
+    const errorClass = hasError ? " is-invalid" : "";
+    const classMatch = attrs.match(/class=['"]([^'"]+)['"]/i);
+    const existingClass = classMatch ? classMatch[1] : "";
+    const className = existingClass ? `${existingClass}${errorClass}` : `form-control${errorClass}`;
+    let attrsWithoutClassAndType = attrs.replace(/class=['"][^'"]+['"]/i, "");
+    attrsWithoutClassAndType = attrsWithoutClassAndType.replace(/type=['"][^'"]+['"]/i, "");
+    return `<input type="${type}" name="${name}" value="${oldValue}" class="${className}"${attrsWithoutClassAndType ? ` ${attrsWithoutClassAndType}` : ""}>`;
+  });
+  result = result.replace(/@textarea\(\s*['"]([^'"]+)['"]\s*(?:,\s*\{([^}]+)\})?\)([\s\S]*?)@endtextarea/g, (match, name, attributes = "", content = "") => {
+    const attrs = parseAttributes(attributes);
+    const oldValue = getOldValue(name, context) || content.trim();
+    const hasError = hasFieldError(name, context);
+    const errorClass = hasError ? " is-invalid" : "";
+    const classMatch = attrs.match(/class=['"]([^'"]+)['"]/i);
+    const existingClass = classMatch ? classMatch[1] : "";
+    const className = existingClass ? `${existingClass}${errorClass}` : `form-control${errorClass}`;
+    const attrsWithoutClass = attrs.replace(/class=['"][^'"]+['"]/i, "");
+    return `<textarea name="${name}" class="${className}"${attrsWithoutClass ? ` ${attrsWithoutClass}` : ""}>${oldValue}</textarea>`;
+  });
+  result = result.replace(/@select\(\s*['"]([^'"]+)['"]\s*(?:,\s*\{([^}]+)\})?\)([\s\S]*?)@endselect/g, (match, name, attributes = "", content) => {
+    const attrs = parseAttributes(attributes);
+    const oldValue = getOldValue(name, context);
+    const hasError = hasFieldError(name, context);
+    const errorClass = hasError ? " is-invalid" : "";
+    const classMatch = attrs.match(/class=['"]([^'"]+)['"]/i);
+    const existingClass = classMatch ? classMatch[1] : "";
+    const className = existingClass ? `${existingClass}${errorClass}` : `form-control${errorClass}`;
+    const attrsWithoutClass = attrs.replace(/class=['"][^'"]+['"]/i, "");
+    let processedContent = content;
+    if (oldValue !== undefined) {
+      processedContent = content.replace(/(<option[^>]*value=['"]([^'"]+)['"][^>]*>)/gi, (optionMatch, optionTag, optionValue) => {
+        const isSelected = Array.isArray(oldValue) ? oldValue.includes(optionValue) : oldValue === optionValue;
+        if (isSelected && !optionTag.includes("selected")) {
+          return optionTag.replace(/(<option)/, "$1 selected");
+        }
+        return optionMatch;
+      });
+    }
+    return `<select name="${name}" class="${className}"${attrsWithoutClass ? ` ${attrsWithoutClass}` : ""}>${processedContent}</select>`;
+  });
+  result = result.replace(/@checkbox\(\s*['"]([^'"]+)['"]\s*(?:,\s*['"]([^'"]+)['"]\s*)?(?:,\s*\{([^}]+)\})?\)/g, (match, name, value = "1", attributes = "") => {
+    const attrs = parseAttributes(attributes);
+    const oldValues = getOldValue(name, context);
+    const isChecked = oldValues !== undefined && (Array.isArray(oldValues) ? oldValues.includes(value) : oldValues === value || oldValues === true);
+    const classMatch = attrs.match(/class=['"]([^'"]+)['"]/i);
+    const existingClass = classMatch ? classMatch[1] : "";
+    const className = existingClass || "form-check-input";
+    const attrsWithoutClass = attrs.replace(/class=['"][^'"]+['"]/i, "");
+    return `<input type="checkbox" name="${name}" value="${value}" class="${className}"${isChecked ? " checked" : ""}${attrsWithoutClass ? ` ${attrsWithoutClass}` : ""}>`;
+  });
+  result = result.replace(/@radio\(\s*['"]([^'"]+)['"]\s*,\s*['"]([^'"]+)['"]\s*(?:,\s*\{([^}]+)\})?\)/g, (match, name, value, attributes = "") => {
+    const attrs = parseAttributes(attributes);
+    const oldValue = getOldValue(name, context);
+    const isChecked = oldValue !== undefined && oldValue === value;
+    const classMatch = attrs.match(/class=['"]([^'"]+)['"]/i);
+    const existingClass = classMatch ? classMatch[1] : "";
+    const className = existingClass || "form-check-input";
+    const attrsWithoutClass = attrs.replace(/class=['"][^'"]+['"]/i, "");
+    return `<input type="radio" name="${name}" value="${value}" class="${className}"${isChecked ? " checked" : ""}${attrsWithoutClass ? ` ${attrsWithoutClass}` : ""}>`;
+  });
+  result = result.replace(/@label\(\s*['"]([^'"]+)['"]\s*(?:,\s*\{([^}]+)\})?\)([\s\S]*?)@endlabel/g, (match, forAttr, attributes = "", content) => {
+    const attrs = parseAttributes(attributes);
+    const classMatch = attrs.match(/class=['"]([^'"]+)['"]/i);
+    const existingClass = classMatch ? classMatch[1] : "";
+    const className = existingClass || "form-label";
+    const attrsWithoutClass = attrs.replace(/class=['"][^'"]+['"]/i, "");
+    return `<label for="${forAttr}" class="${className}"${attrsWithoutClass ? ` ${attrsWithoutClass}` : ""}>${content}</label>`;
+  });
+  return result;
+}
+function processErrorDirective(template, context) {
+  return template.replace(/@error\(['"]([^'"]+)['"]\)([\s\S]*?)@enderror/g, (match, field, content) => {
+    try {
+      if (hasFieldError(field, context)) {
+        return content.replace(/\{\{([^}]+)\}\}/g, (_, expr) => {
+          try {
+            if (expr.trim() === "$message" || expr.trim() === "message") {
+              return getErrorMessage(field, context);
+            }
+            if (expr.trim().includes("errors.first") || expr.trim().includes("$errors.first")) {
+              if (typeof context.errors?.first === "function") {
+                return context.errors.first(field);
+              }
+              return getErrorMessage(field, context);
+            }
+            const evalFn = new Function(...Object.keys(context), `
+              try { return ${expr.trim()}; } catch (e) { return '${expr.trim()}'; }
+            `);
+            return evalFn(...Object.values(context));
+          } catch {
+            return expr;
+          }
+        });
+      }
+      return "";
+    } catch (error) {
+      console.error(`Error processing @error directive:`, error);
+      return match;
+    }
+  });
+}
+function hasFieldError(field, context) {
+  if (!context.errors)
+    return false;
+  if (typeof context.errors.has === "function") {
+    return context.errors.has(field);
+  }
+  if (typeof context.errors === "object") {
+    return Object.prototype.hasOwnProperty.call(context.errors, field);
+  }
+  return false;
+}
+function getErrorMessage(field, context) {
+  if (!context.errors)
+    return "";
+  if (typeof context.errors.get === "function") {
+    return context.errors.get(field);
+  }
+  if (typeof context.errors === "object" && Object.prototype.hasOwnProperty.call(context.errors, field)) {
+    const error = context.errors[field];
+    return Array.isArray(error) ? error[0] : String(error);
+  }
+  return "";
+}
+function getOldValue(field, context) {
+  let value;
+  if (context.old && typeof context.old === "function") {
+    return context.old(field);
+  }
+  if (context.old && typeof context.old === "object") {
+    return context.old[field];
+  }
+  if (field.endsWith("[]")) {
+    const baseName = field.slice(0, -2);
+    value = context[baseName];
+    if (value !== undefined) {
+      return value;
+    }
+  }
+  return context[field];
+}
+function parseAttributes(attributesStr) {
+  if (!attributesStr.trim())
+    return "";
+  const attrs = [];
+  const attrRegex = /([\w-]+)\s*:\s*(['"]?)([^,'"]*)\2(?:,|$)/g;
+  let match;
+  while ((match = attrRegex.exec(attributesStr)) !== null) {
+    const [, name, , value] = match;
+    attrs.push(`${name}="${value.trim()}"`);
+  }
+  return attrs.join(" ");
+}
+function processFormDirectives(template, context) {
+  let result = template;
+  result = result.replace(/@csrf/g, () => {
+    if (context.csrf && typeof context.csrf === "object") {
+      if (context.csrf.field) {
+        return context.csrf.field;
+      }
+      if (context.csrf.token) {
+        return `<input type="hidden" name="_token" value="${context.csrf.token}">`;
+      }
+    }
+    return '<input type="hidden" name="_token" value="">';
+  });
+  result = result.replace(/@method\(['"]([^'"]+)['"]\)/g, (match, method) => {
+    if (method && ["PUT", "PATCH", "DELETE"].includes(method.toUpperCase())) {
+      return `<input type="hidden" name="_method" value="${method.toUpperCase()}">`;
+    }
+    return match;
+  });
+  return result;
+}
+
+// src/i18n.ts
+import fs from "fs";
+import path from "path";
+var defaultI18nConfig = {
+  defaultLocale: "en",
+  locale: "en",
+  translationsDir: "translations",
+  format: "yaml",
+  fallbackToKey: true,
+  cache: true
+};
+var translationsCache = {};
+async function loadTranslation(locale, options) {
+  const i18nConfig = {
+    ...defaultI18nConfig,
+    ...options.i18n
+  };
+  if (i18nConfig.cache && translationsCache[locale]) {
+    return translationsCache[locale];
+  }
+  const translationsDir = path.resolve(import.meta.dir, "..", i18nConfig.translationsDir);
+  const fileExtension = getFileExtension(i18nConfig.format);
+  const translationFile = path.join(translationsDir, `${locale}${fileExtension}`);
+  try {
+    let translations = {};
+    if (i18nConfig.format === "js") {
+      const imported = await import(translationFile);
+      translations = imported.default || imported;
+    } else {
+      const content = await fs.promises.readFile(translationFile, "utf-8");
+      if (i18nConfig.format === "yaml" || i18nConfig.format === "yml") {
+        translations = await parseYaml(content);
+      } else {
+        translations = JSON.parse(content);
+      }
+    }
+    if (i18nConfig.cache) {
+      translationsCache[locale] = translations;
+    }
+    return translations;
+  } catch (error) {
+    if (options.debug) {
+      console.error(`Error loading translation file for locale "${locale}":`, error);
+    }
+    if (locale !== i18nConfig.defaultLocale) {
+      return loadTranslation(i18nConfig.defaultLocale, options);
+    }
+    return {};
+  }
+}
+async function parseYaml(content) {
+  try {
+    const { parse } = await import("./chunk-04bqmpzb.js");
+    return parse(content) || {};
+  } catch (importError) {
+    console.error("Failed to import yaml parser:", importError);
+    try {
+      if (typeof Bun !== "undefined") {
+        return Bun.YAML?.parse?.(content) || {};
+      }
+      throw new Error("No YAML parser available");
+    } catch (error) {
+      console.error("Failed to parse YAML content:", error);
+      throw new Error('Could not parse YAML. Please install the "yaml" package or use JSON format instead.');
+    }
+  }
+}
+function getFileExtension(format) {
+  switch (format) {
+    case "yaml":
+      return ".yaml";
+    case "yml":
+      return ".yml";
+    case "js":
+      return ".js";
+    case "json":
+    default:
+      return ".json";
+  }
+}
+function getTranslation(key, translations, fallbackToKey = true, params = {}) {
+  const parts = key.split(".");
+  let value = translations;
+  for (const part of parts) {
+    if (value === undefined || value === null) {
+      break;
+    }
+    value = value[part];
+  }
+  if (value === undefined || value === null) {
+    return fallbackToKey ? key : "";
+  }
+  let result = String(value);
+  Object.entries(params).forEach(([paramKey, paramValue]) => {
+    result = result.replace(new RegExp(`:${paramKey}`, "g"), String(paramValue));
+  });
+  return result;
+}
+async function processTranslateDirective(template, context, filePath, options) {
+  let output = template;
+  const fixedTranslateRegex = /@translate\(\s*['"]([^'"]+)['"]\s*(?:,\s*(\{[^}]*\})\s*)?\)([\s\S]*?)@endtranslate/g;
+  const i18nConfig = {
+    ...defaultI18nConfig,
+    ...options.i18n
+  };
+  const translations = await loadTranslation(i18nConfig.locale, options);
+  context.__translations = translations;
+  context.__locale = i18nConfig.locale;
+  context.__i18nConfig = i18nConfig;
+  output = await replaceAsync(output, fixedTranslateRegex, async (match, key, paramsStr, content, offset) => {
+    try {
+      let params = {};
+      if (paramsStr) {
+        try {
+          const approaches = [
+            () => JSON.parse(paramsStr),
+            () => {
+              const jsonStr = `{"data":${paramsStr}}`;
+              const parsed = JSON.parse(jsonStr);
+              return typeof parsed.data === "object" ? parsed.data : {};
+            },
+            () => {
+              const evalFn = new Function(`return ${paramsStr}`);
+              const result = evalFn();
+              return typeof result === "object" ? result : {};
+            }
+          ];
+          for (const approach of approaches) {
+            try {
+              params = approach();
+              if (Object.keys(params).length > 0) {
+                break;
+              }
+            } catch {}
+          }
+        } catch (error) {
+          if (options.debug) {
+            console.error(`Error parsing parameters for @translate directive:`, error);
+          }
+        }
+      }
+      const translation = getTranslation(key, translations, i18nConfig.fallbackToKey, params);
+      return translation || content.trim();
+    } catch (error) {
+      if (options.debug) {
+        console.error(`Error processing @translate directive:`, error);
+      }
+      return createDetailedErrorMessage("Translate", `Error in @translate('${key}'): ${error instanceof Error ? error.message : String(error)}`, filePath, template, offset, match);
+    }
+  });
+  const inlineTranslateRegex = /@translate\(\s*['"]([^'"]+)['"]\s*(?:,\s*(\{[^}]+\})\s*)?\)/g;
+  if (options.debug) {
+    console.warn(`Processing translations in template. Sections: ${output.includes("<h2>Translation with Parameters</h2>") ? "Parameters section found" : "Parameters section missing"}`);
+    const matches = [...output.matchAll(inlineTranslateRegex)];
+    console.warn(`Found ${matches.length} @translate matches`);
+    matches.forEach((m, i) => console.warn(`Match ${i}: ${m[0]}, Key: ${m[1]}, Params: ${m[2] || "none"}`));
+  }
+  const fixedInlineTranslateRegex = /@translate\(\s*['"]([^'"]+)['"]\s*(?:,\s*(\{[^}]*\})\s*)?\)/g;
+  output = await replaceAsync(output, fixedInlineTranslateRegex, async (match, key, paramsStr, offset) => {
+    try {
+      let params = {};
+      if (paramsStr) {
+        try {
+          const approaches = [
+            () => JSON.parse(paramsStr),
+            () => {
+              const jsonStr = `{"data":${paramsStr}}`;
+              const parsed = JSON.parse(jsonStr);
+              return typeof parsed.data === "object" ? parsed.data : {};
+            },
+            () => {
+              const evalFn = new Function(`return ${paramsStr}`);
+              const result = evalFn();
+              return typeof result === "object" ? result : {};
+            }
+          ];
+          for (const approach of approaches) {
+            try {
+              params = approach();
+              if (Object.keys(params).length > 0) {
+                break;
+              }
+            } catch {}
+          }
+        } catch (error) {
+          if (options.debug) {
+            console.error(`Error parsing parameters for @translate directive:`, error);
+          }
+        }
+      }
+      return getTranslation(key, translations, i18nConfig.fallbackToKey, params);
+    } catch (error) {
+      if (options.debug) {
+        console.error(`Error processing @translate directive:`, error);
+      }
+      return createDetailedErrorMessage("Translate", `Error in @translate('${key}'): ${error instanceof Error ? error.message : String(error)}`, filePath, template, offset, match);
+    }
+  });
+  return output;
+}
+async function replaceAsync(str, regex, asyncFn) {
+  const promises = [];
+  str.replace(regex, (match, ...args) => {
+    const promise = asyncFn(match, ...args).then((replacement) => ({
+      match,
+      replacement
+    }));
+    promises.push(promise);
+    return match;
+  });
+  const results = await Promise.all(promises);
+  return results.reduce((str2, { match, replacement }) => str2.replace(match, replacement), str);
+}
+function createTranslateFilter(translations, fallbackToKey = true) {
+  return (value, params = {}) => {
+    return getTranslation(value, translations, fallbackToKey, params);
+  };
+}
+
+// src/includes.ts
+import fs2 from "fs";
+import path2 from "path";
+var partialsCache = new Map;
+async function processIncludes(template, context, filePath, options, dependencies) {
+  const partialsDir = options.partialsDir || path2.join(path2.dirname(filePath), "partials");
+  let output = template.replace(/@partial\s*\(['"]([^'"]+)['"](?:,\s*(\{[^}]*\}))?\)/g, (_, includePath, varsString) => `@include('${includePath}'${varsString ? `, ${varsString}` : ""})`);
+  output = output.replace(/@includeIf\s*\(['"]([^'"]+)['"](?:,\s*(\{[^}]*\}))?\)/g, (_, includePath, varsString) => {
+    const includeFilePath = resolvePath(includePath, partialsDir, filePath);
+    if (includeFilePath && fs2.existsSync(includeFilePath)) {
+      dependencies.add(includeFilePath);
+      return `@include('${includePath}'${varsString ? `, ${varsString}` : ""})`;
+    }
+    return "";
+  });
+  output = output.replace(/@includeWhen\s*\(([^,]+),\s*['"]([^'"]+)['"](?:,\s*(\{[^}]*\}))?\)/g, (match2, condition, includePath, varsString, offset) => {
+    try {
+      const conditionFn = new Function(...Object.keys(context), `return Boolean(${condition})`);
+      const shouldInclude = conditionFn(...Object.values(context));
+      if (shouldInclude) {
+        const includeFilePath = resolvePath(includePath, partialsDir, filePath);
+        if (includeFilePath && fs2.existsSync(includeFilePath)) {
+          dependencies.add(includeFilePath);
+        }
+        return `@include('${includePath}'${varsString ? `, ${varsString}` : ""})`;
+      }
+      return "";
+    } catch (error) {
+      return createDetailedErrorMessage("Include", `Error evaluating @includeWhen condition: ${error.message}`, filePath, template, offset, match2);
+    }
+  });
+  output = output.replace(/@includeUnless\s*\(([^,]+),\s*['"]([^'"]+)['"](?:,\s*(\{[^}]*\}))?\)/g, (match2, condition, includePath, varsString, offset) => {
+    try {
+      const conditionFn = new Function(...Object.keys(context), `return Boolean(${condition})`);
+      const conditionResult = conditionFn(...Object.values(context));
+      if (!conditionResult) {
+        const includeFilePath = resolvePath(includePath, partialsDir, filePath);
+        if (includeFilePath && fs2.existsSync(includeFilePath)) {
+          dependencies.add(includeFilePath);
+        }
+        return `@include('${includePath}'${varsString ? `, ${varsString}` : ""})`;
+      }
+      return "";
+    } catch (error) {
+      return createDetailedErrorMessage("Include", `Error evaluating @includeUnless condition: ${error.message}`, filePath, template, offset, match2);
+    }
+  });
+  const includeFirstRegex = /@includeFirst\s*\(\s*(\[[^\]]+\])\s*(?:,\s*(\{[^}]+\})\s*)?\)/g;
+  let includeFirstMatch;
+  while (includeFirstMatch = includeFirstRegex.exec(output)) {
+    const [fullMatch, pathArrayString, varsString] = includeFirstMatch;
+    const matchOffset = includeFirstMatch.index;
+    try {
+      const pathArray = JSON.parse(pathArrayString.replace(/'/g, '"'));
+      let localVars = {};
+      if (varsString) {
+        try {
+          const varsFn = new Function(`return ${varsString}`);
+          localVars = varsFn();
+        } catch (error) {
+          output = output.replace(fullMatch, createDetailedErrorMessage("Include", `Error parsing includeFirst variables: ${error.message}`, filePath, template, matchOffset, fullMatch));
+          continue;
+        }
+      }
+      let foundValidPath = false;
+      for (const includePath of pathArray) {
+        const includeFilePath = resolvePath(includePath, partialsDir, filePath);
+        if (!includeFilePath) {
+          continue;
+        }
+        if (await fileExists(includeFilePath)) {
+          const processed = await processIncludeHelper(includePath, localVars, template, matchOffset);
+          output = output.replace(fullMatch, processed);
+          foundValidPath = true;
+          break;
+        }
+      }
+      if (!foundValidPath) {
+        output = output.replace(fullMatch, createDetailedErrorMessage("Include", `None of the includeFirst paths exist: ${pathArrayString}`, filePath, template, matchOffset, fullMatch));
+      }
+    } catch (error) {
+      output = output.replace(fullMatch, createDetailedErrorMessage("Include", `Error processing @includeFirst: ${error.message}`, filePath, template, matchOffset, fullMatch));
+    }
+    includeFirstRegex.lastIndex = 0;
+  }
+  function resolvePath(includePath, partialsDir2, filePath2) {
+    try {
+      let includeFilePath = includePath;
+      if (!includePath.endsWith(".stx")) {
+        includeFilePath = `${includePath}.stx`;
+      }
+      if (!includeFilePath.startsWith("./") && !includeFilePath.startsWith("../")) {
+        includeFilePath = path2.join(partialsDir2, includeFilePath);
+      } else {
+        includeFilePath = path2.resolve(path2.dirname(filePath2), includeFilePath);
+      }
+      return includeFilePath;
+    } catch (error) {
+      console.error(`Error resolving path ${includePath}: ${error}`);
+      return null;
+    }
+  }
+  const processedIncludes = new Set;
+  async function processIncludeHelper(includePath, localVars = {}, templateStr, offsetPos) {
+    if (processedIncludes.has(includePath)) {
+      return createDetailedErrorMessage("Include", `Circular include detected: ${includePath}`, filePath, templateStr, offsetPos);
+    }
+    processedIncludes.add(includePath);
+    try {
+      const includeFilePath = resolvePath(includePath, partialsDir, filePath);
+      if (!includeFilePath) {
+        return createDetailedErrorMessage("Include", `Could not resolve path for include: ${includePath}`, filePath, templateStr, offsetPos);
+      }
+      dependencies.add(includeFilePath);
+      let partialContent = partialsCache.get(includeFilePath);
+      if (!partialContent) {
+        try {
+          partialContent = await Bun.file(includeFilePath).text();
+          partialsCache.set(includeFilePath, partialContent);
+        } catch (error) {
+          return createDetailedErrorMessage("Include", `Error loading include file ${includePath}: ${error.message}`, filePath, templateStr, offsetPos);
+        }
+      }
+      const includeContext = { ...context };
+      for (const [key, value] of Object.entries(localVars)) {
+        includeContext[key] = value;
+      }
+      if (partialContent.includes("@include") || partialContent.includes("@partial")) {
+        partialContent = await processIncludes(partialContent, includeContext, includeFilePath, options, dependencies);
+      }
+      const { processLoops } = await import("./chunk-zhs1t2p5.js");
+      let processedContent = processLoops(partialContent, includeContext, includeFilePath);
+      processedContent = processConditionals(processedContent, includeContext, includeFilePath);
+      processedContent = processExpressions(processedContent, includeContext, includeFilePath);
+      return processedContent;
+    } catch (error) {
+      return createDetailedErrorMessage("Include", `Error processing include ${includePath}: ${error.message}`, filePath, templateStr, offsetPos);
+    } finally {
+      processedIncludes.delete(includePath);
+    }
+  }
+  const includeRegex = /@include\s*\(['"]([^'"]+)['"](?:,\s*(\{[^}]*\}))?\)/g;
+  let match;
+  while (match = includeRegex.exec(output)) {
+    const [fullMatch, includePath, varsString] = match;
+    const matchOffset = match.index;
+    let localVars = {};
+    if (varsString) {
+      try {
+        const varsFn = new Function(`return ${varsString}`);
+        localVars = varsFn();
+      } catch (error) {
+        output = output.replace(fullMatch, createDetailedErrorMessage("Include", `Error parsing include variables for ${includePath}: ${error.message}`, filePath, template, matchOffset));
+        continue;
+      }
+    }
+    const processedContent = await processIncludeHelper(includePath, localVars, template, matchOffset);
+    output = output.replace(fullMatch, processedContent);
+    includeRegex.lastIndex = 0;
+  }
+  return output;
+}
+function processStackPushDirectives(template, stacks) {
+  let result = template;
+  result = result.replace(/@push\(['"]([^'"]+)['"]\)([\s\S]*?)@endpush/g, (match, name, content) => {
+    if (!stacks[name]) {
+      stacks[name] = [];
+    }
+    stacks[name].push(content);
+    return "";
+  });
+  result = result.replace(/@prepend\(['"]([^'"]+)['"]\)([\s\S]*?)@endprepend/g, (match, name, content) => {
+    if (!stacks[name]) {
+      stacks[name] = [];
+    }
+    stacks[name].unshift(content);
+    return "";
+  });
+  return result;
+}
+function processStackReplacements(template, stacks) {
+  return template.replace(/@stack\(['"]([^'"]+)['"]\)/g, (match, name) => {
+    if (!stacks[name] || stacks[name].length === 0) {
+      return "";
+    }
+    return stacks[name].join(`
+`);
+  });
+}
+
+// ../../node_modules/marked/lib/marked.esm.js
+function _getDefaults() {
+  return {
+    async: false,
+    breaks: false,
+    extensions: null,
+    gfm: true,
+    hooks: null,
+    pedantic: false,
+    renderer: null,
+    silent: false,
+    tokenizer: null,
+    walkTokens: null
+  };
+}
+var _defaults = _getDefaults();
+function changeDefaults(newDefaults) {
+  _defaults = newDefaults;
+}
+var noopTest = { exec: () => null };
+function edit(regex, opt = "") {
+  let source = typeof regex === "string" ? regex : regex.source;
+  const obj = {
+    replace: (name, val) => {
+      let valSource = typeof val === "string" ? val : val.source;
+      valSource = valSource.replace(other.caret, "$1");
+      source = source.replace(name, valSource);
+      return obj;
+    },
+    getRegex: () => {
+      return new RegExp(source, opt);
+    }
+  };
+  return obj;
+}
+var other = {
+  codeRemoveIndent: /^(?: {1,4}| {0,3}\t)/gm,
+  outputLinkReplace: /\\([\[\]])/g,
+  indentCodeCompensation: /^(\s+)(?:```)/,
+  beginningSpace: /^\s+/,
+  endingHash: /#$/,
+  startingSpaceChar: /^ /,
+  endingSpaceChar: / $/,
+  nonSpaceChar: /[^ ]/,
+  newLineCharGlobal: /\n/g,
+  tabCharGlobal: /\t/g,
+  multipleSpaceGlobal: /\s+/g,
+  blankLine: /^[ \t]*$/,
+  doubleBlankLine: /\n[ \t]*\n[ \t]*$/,
+  blockquoteStart: /^ {0,3}>/,
+  blockquoteSetextReplace: /\n {0,3}((?:=+|-+) *)(?=\n|$)/g,
+  blockquoteSetextReplace2: /^ {0,3}>[ \t]?/gm,
+  listReplaceTabs: /^\t+/,
+  listReplaceNesting: /^ {1,4}(?=( {4})*[^ ])/g,
+  listIsTask: /^\[[ xX]\] /,
+  listReplaceTask: /^\[[ xX]\] +/,
+  anyLine: /\n.*\n/,
+  hrefBrackets: /^<(.*)>$/,
+  tableDelimiter: /[:|]/,
+  tableAlignChars: /^\||\| *$/g,
+  tableRowBlankLine: /\n[ \t]*$/,
+  tableAlignRight: /^ *-+: *$/,
+  tableAlignCenter: /^ *:-+: *$/,
+  tableAlignLeft: /^ *:-+ *$/,
+  startATag: /^<a /i,
+  endATag: /^<\/a>/i,
+  startPreScriptTag: /^<(pre|code|kbd|script)(\s|>)/i,
+  endPreScriptTag: /^<\/(pre|code|kbd|script)(\s|>)/i,
+  startAngleBracket: /^</,
+  endAngleBracket: />$/,
+  pedanticHrefTitle: /^([^'"]*[^\s])\s+(['"])(.*)\2/,
+  unicodeAlphaNumeric: /[\p{L}\p{N}]/u,
+  escapeTest: /[&<>"']/,
+  escapeReplace: /[&<>"']/g,
+  escapeTestNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/,
+  escapeReplaceNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/g,
+  unescapeTest: /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig,
+  caret: /(^|[^\[])\^/g,
+  percentDecode: /%25/g,
+  findPipe: /\|/g,
+  splitPipe: / \|/,
+  slashPipe: /\\\|/g,
+  carriageReturn: /\r\n|\r/g,
+  spaceLine: /^ +$/gm,
+  notSpaceStart: /^\S*/,
+  endingNewline: /\n$/,
+  listItemRegex: (bull) => new RegExp(`^( {0,3}${bull})((?:[	 ][^\\n]*)?(?:\\n|$))`),
+  nextBulletRegex: (indent) => new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ 	][^\\n]*)?(?:\\n|$))`),
+  hrRegex: (indent) => new RegExp(`^ {0,${Math.min(3, indent - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`),
+  fencesBeginRegex: (indent) => new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:\`\`\`|~~~)`),
+  headingBeginRegex: (indent) => new RegExp(`^ {0,${Math.min(3, indent - 1)}}#`),
+  htmlBeginRegex: (indent) => new RegExp(`^ {0,${Math.min(3, indent - 1)}}<(?:[a-z].*>|!--)`, "i")
+};
+var newline = /^(?:[ \t]*(?:\n|$))+/;
+var blockCode = /^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/;
+var fences = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/;
+var hr = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/;
+var heading = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/;
+var bullet = /(?:[*+-]|\d{1,9}[.)])/;
+var lheadingCore = /^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\n {0,3}(=+|-+) *(?:\n+|$)/;
+var lheading = edit(lheadingCore).replace(/bull/g, bullet).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/\|table/g, "").getRegex();
+var lheadingGfm = edit(lheadingCore).replace(/bull/g, bullet).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/table/g, / {0,3}\|?(?:[:\- ]*\|)+[\:\- ]*\n/).getRegex();
+var _paragraph = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/;
+var blockText = /^[^\n]+/;
+var _blockLabel = /(?!\s*\])(?:\\.|[^\[\]\\])+/;
+var def = edit(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace("label", _blockLabel).replace("title", /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex();
+var list = edit(/^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g, bullet).getRegex();
+var _tag = "address|article|aside|base|basefont|blockquote|body|caption" + "|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption" + "|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe" + "|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option" + "|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title" + "|tr|track|ul";
+var _comment = /<!--(?:-?>|[\s\S]*?(?:-->|$))/;
+var html = edit("^ {0,3}(?:" + "<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)" + "|comment[^\\n]*(\\n+|$)" + "|<\\?[\\s\\S]*?(?:\\?>\\n*|$)" + "|<![A-Z][\\s\\S]*?(?:>\\n*|$)" + "|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)" + "|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$)" + "|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$)" + "|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$)" + ")", "i").replace("comment", _comment).replace("tag", _tag).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex();
+var paragraph = edit(_paragraph).replace("hr", hr).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("|table", "").replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", _tag).getRegex();
+var blockquote = edit(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph", paragraph).getRegex();
+var blockNormal = {
+  blockquote,
+  code: blockCode,
+  def,
+  fences,
+  heading,
+  hr,
+  html,
+  lheading,
+  list,
+  newline,
+  paragraph,
+  table: noopTest,
+  text: blockText
+};
+var gfmTable = edit("^ *([^\\n ].*)\\n" + " {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)" + "(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr", hr).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("blockquote", " {0,3}>").replace("code", "(?: {4}| {0,3}\t)[^\\n]").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", _tag).getRegex();
+var blockGfm = {
+  ...blockNormal,
+  lheading: lheadingGfm,
+  table: gfmTable,
+  paragraph: edit(_paragraph).replace("hr", hr).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("table", gfmTable).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", _tag).getRegex()
+};
+var blockPedantic = {
+  ...blockNormal,
+  html: edit("^ *(?:comment *(?:\\n|\\s*$)" + "|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)" + `|<tag(?:"[^"]*"|'[^']*'|\\s[^'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`).replace("comment", _comment).replace(/tag/g, "(?!(?:" + "a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub" + "|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)" + "\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(),
+  def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,
+  heading: /^(#{1,6})(.*)(?:\n+|$)/,
+  fences: noopTest,
+  lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/,
+  paragraph: edit(_paragraph).replace("hr", hr).replace("heading", ` *#{1,6} *[^
+]`).replace("lheading", lheading).replace("|table", "").replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").replace("|tag", "").getRegex()
+};
+var escape$1 = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/;
+var inlineCode = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/;
+var br = /^( {2,}|\\)\n(?!\s*$)/;
+var inlineText = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/;
+var _punctuation = /[\p{P}\p{S}]/u;
+var _punctuationOrSpace = /[\s\p{P}\p{S}]/u;
+var _notPunctuationOrSpace = /[^\s\p{P}\p{S}]/u;
+var punctuation = edit(/^((?![*_])punctSpace)/, "u").replace(/punctSpace/g, _punctuationOrSpace).getRegex();
+var _punctuationGfmStrongEm = /(?!~)[\p{P}\p{S}]/u;
+var _punctuationOrSpaceGfmStrongEm = /(?!~)[\s\p{P}\p{S}]/u;
+var _notPunctuationOrSpaceGfmStrongEm = /(?:[^\s\p{P}\p{S}]|~)/u;
+var blockSkip = /\[[^[\]]*?\]\((?:\\.|[^\\\(\)]|\((?:\\.|[^\\\(\)])*\))*\)|`[^`]*?`|<[^<>]*?>/g;
+var emStrongLDelimCore = /^(?:\*+(?:((?!\*)punct)|[^\s*]))|^_+(?:((?!_)punct)|([^\s_]))/;
+var emStrongLDelim = edit(emStrongLDelimCore, "u").replace(/punct/g, _punctuation).getRegex();
+var emStrongLDelimGfm = edit(emStrongLDelimCore, "u").replace(/punct/g, _punctuationGfmStrongEm).getRegex();
+var emStrongRDelimAstCore = "^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)" + "|[^*]+(?=[^*])" + "|(?!\\*)punct(\\*+)(?=[\\s]|$)" + "|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)" + "|(?!\\*)punctSpace(\\*+)(?=notPunctSpace)" + "|[\\s](\\*+)(?!\\*)(?=punct)" + "|(?!\\*)punct(\\*+)(?!\\*)(?=punct)" + "|notPunctSpace(\\*+)(?=notPunctSpace)";
+var emStrongRDelimAst = edit(emStrongRDelimAstCore, "gu").replace(/notPunctSpace/g, _notPunctuationOrSpace).replace(/punctSpace/g, _punctuationOrSpace).replace(/punct/g, _punctuation).getRegex();
+var emStrongRDelimAstGfm = edit(emStrongRDelimAstCore, "gu").replace(/notPunctSpace/g, _notPunctuationOrSpaceGfmStrongEm).replace(/punctSpace/g, _punctuationOrSpaceGfmStrongEm).replace(/punct/g, _punctuationGfmStrongEm).getRegex();
+var emStrongRDelimUnd = edit("^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)" + "|[^_]+(?=[^_])" + "|(?!_)punct(_+)(?=[\\s]|$)" + "|notPunctSpace(_+)(?!_)(?=punctSpace|$)" + "|(?!_)punctSpace(_+)(?=notPunctSpace)" + "|[\\s](_+)(?!_)(?=punct)" + "|(?!_)punct(_+)(?!_)(?=punct)", "gu").replace(/notPunctSpace/g, _notPunctuationOrSpace).replace(/punctSpace/g, _punctuationOrSpace).replace(/punct/g, _punctuation).getRegex();
+var anyPunctuation = edit(/\\(punct)/, "gu").replace(/punct/g, _punctuation).getRegex();
+var autolink = edit(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace("scheme", /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace("email", /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/).getRegex();
+var _inlineComment = edit(_comment).replace("(?:-->|$)", "-->").getRegex();
+var tag = edit("^comment" + "|^</[a-zA-Z][\\w:-]*\\s*>" + "|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>" + "|^<\\?[\\s\\S]*?\\?>" + "|^<![a-zA-Z]+\\s[\\s\\S]*?>" + "|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>").replace("comment", _inlineComment).replace("attribute", /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex();
+var _inlineLabel = /(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/;
+var link = edit(/^!?\[(label)\]\(\s*(href)(?:(?:[ \t]*(?:\n[ \t]*)?)(title))?\s*\)/).replace("label", _inlineLabel).replace("href", /<(?:\\.|[^\n<>\\])+>|[^ \t\n\x00-\x1f]*/).replace("title", /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex();
+var reflink = edit(/^!?\[(label)\]\[(ref)\]/).replace("label", _inlineLabel).replace("ref", _blockLabel).getRegex();
+var nolink = edit(/^!?\[(ref)\](?:\[\])?/).replace("ref", _blockLabel).getRegex();
+var reflinkSearch = edit("reflink|nolink(?!\\()", "g").replace("reflink", reflink).replace("nolink", nolink).getRegex();
+var inlineNormal = {
+  _backpedal: noopTest,
+  anyPunctuation,
+  autolink,
+  blockSkip,
+  br,
+  code: inlineCode,
+  del: noopTest,
+  emStrongLDelim,
+  emStrongRDelimAst,
+  emStrongRDelimUnd,
+  escape: escape$1,
+  link,
+  nolink,
+  punctuation,
+  reflink,
+  reflinkSearch,
+  tag,
+  text: inlineText,
+  url: noopTest
+};
+var inlinePedantic = {
+  ...inlineNormal,
+  link: edit(/^!?\[(label)\]\((.*?)\)/).replace("label", _inlineLabel).getRegex(),
+  reflink: edit(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label", _inlineLabel).getRegex()
+};
+var inlineGfm = {
+  ...inlineNormal,
+  emStrongRDelimAst: emStrongRDelimAstGfm,
+  emStrongLDelim: emStrongLDelimGfm,
+  url: edit(/^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/, "i").replace("email", /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/).getRegex(),
+  _backpedal: /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/,
+  del: /^(~~?)(?=[^\s~])((?:\\.|[^\\])*?(?:\\.|[^\s~\\]))\1(?=[^~]|$)/,
+  text: /^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)))/
+};
+var inlineBreaks = {
+  ...inlineGfm,
+  br: edit(br).replace("{2,}", "*").getRegex(),
+  text: edit(inlineGfm.text).replace("\\b_", "\\b_| {2,}\\n").replace(/\{2,\}/g, "*").getRegex()
+};
+var block = {
+  normal: blockNormal,
+  gfm: blockGfm,
+  pedantic: blockPedantic
+};
+var inline = {
+  normal: inlineNormal,
+  gfm: inlineGfm,
+  breaks: inlineBreaks,
+  pedantic: inlinePedantic
+};
+var escapeReplacements = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+var getEscapeReplacement = (ch) => escapeReplacements[ch];
+function escape(html2, encode) {
+  if (encode) {
+    if (other.escapeTest.test(html2)) {
+      return html2.replace(other.escapeReplace, getEscapeReplacement);
+    }
+  } else {
+    if (other.escapeTestNoEncode.test(html2)) {
+      return html2.replace(other.escapeReplaceNoEncode, getEscapeReplacement);
+    }
+  }
+  return html2;
+}
+function cleanUrl(href) {
+  try {
+    href = encodeURI(href).replace(other.percentDecode, "%");
+  } catch {
+    return null;
+  }
+  return href;
+}
+function splitCells(tableRow, count) {
+  const row = tableRow.replace(other.findPipe, (match, offset, str) => {
+    let escaped = false;
+    let curr = offset;
+    while (--curr >= 0 && str[curr] === "\\")
+      escaped = !escaped;
+    if (escaped) {
+      return "|";
+    } else {
+      return " |";
+    }
+  }), cells = row.split(other.splitPipe);
+  let i = 0;
+  if (!cells[0].trim()) {
+    cells.shift();
+  }
+  if (cells.length > 0 && !cells.at(-1)?.trim()) {
+    cells.pop();
+  }
+  if (count) {
+    if (cells.length > count) {
+      cells.splice(count);
+    } else {
+      while (cells.length < count)
+        cells.push("");
+    }
+  }
+  for (;i < cells.length; i++) {
+    cells[i] = cells[i].trim().replace(other.slashPipe, "|");
+  }
+  return cells;
+}
+function rtrim(str, c, invert) {
+  const l = str.length;
+  if (l === 0) {
+    return "";
+  }
+  let suffLen = 0;
+  while (suffLen < l) {
+    const currChar = str.charAt(l - suffLen - 1);
+    if (currChar === c && true) {
+      suffLen++;
+    } else {
+      break;
+    }
+  }
+  return str.slice(0, l - suffLen);
+}
+function findClosingBracket(str, b) {
+  if (str.indexOf(b[1]) === -1) {
+    return -1;
+  }
+  let level = 0;
+  for (let i = 0;i < str.length; i++) {
+    if (str[i] === "\\") {
+      i++;
+    } else if (str[i] === b[0]) {
+      level++;
+    } else if (str[i] === b[1]) {
+      level--;
+      if (level < 0) {
+        return i;
+      }
+    }
+  }
+  if (level > 0) {
+    return -2;
+  }
+  return -1;
+}
+function outputLink(cap, link2, raw, lexer, rules) {
+  const href = link2.href;
+  const title = link2.title || null;
+  const text = cap[1].replace(rules.other.outputLinkReplace, "$1");
+  lexer.state.inLink = true;
+  const token = {
+    type: cap[0].charAt(0) === "!" ? "image" : "link",
+    raw,
+    href,
+    title,
+    text,
+    tokens: lexer.inlineTokens(text)
+  };
+  lexer.state.inLink = false;
+  return token;
+}
+function indentCodeCompensation(raw, text, rules) {
+  const matchIndentToCode = raw.match(rules.other.indentCodeCompensation);
+  if (matchIndentToCode === null) {
+    return text;
+  }
+  const indentToCode = matchIndentToCode[1];
+  return text.split(`
+`).map((node) => {
+    const matchIndentInNode = node.match(rules.other.beginningSpace);
+    if (matchIndentInNode === null) {
+      return node;
+    }
+    const [indentInNode] = matchIndentInNode;
+    if (indentInNode.length >= indentToCode.length) {
+      return node.slice(indentToCode.length);
+    }
+    return node;
+  }).join(`
+`);
+}
+
+class _Tokenizer {
+  options;
+  rules;
+  lexer;
+  constructor(options) {
+    this.options = options || _defaults;
+  }
+  space(src) {
+    const cap = this.rules.block.newline.exec(src);
+    if (cap && cap[0].length > 0) {
+      return {
+        type: "space",
+        raw: cap[0]
+      };
+    }
+  }
+  code(src) {
+    const cap = this.rules.block.code.exec(src);
+    if (cap) {
+      const text = cap[0].replace(this.rules.other.codeRemoveIndent, "");
+      return {
+        type: "code",
+        raw: cap[0],
+        codeBlockStyle: "indented",
+        text: !this.options.pedantic ? rtrim(text, `
+`) : text
+      };
+    }
+  }
+  fences(src) {
+    const cap = this.rules.block.fences.exec(src);
+    if (cap) {
+      const raw = cap[0];
+      const text = indentCodeCompensation(raw, cap[3] || "", this.rules);
+      return {
+        type: "code",
+        raw,
+        lang: cap[2] ? cap[2].trim().replace(this.rules.inline.anyPunctuation, "$1") : cap[2],
+        text
+      };
+    }
+  }
+  heading(src) {
+    const cap = this.rules.block.heading.exec(src);
+    if (cap) {
+      let text = cap[2].trim();
+      if (this.rules.other.endingHash.test(text)) {
+        const trimmed = rtrim(text, "#");
+        if (this.options.pedantic) {
+          text = trimmed.trim();
+        } else if (!trimmed || this.rules.other.endingSpaceChar.test(trimmed)) {
+          text = trimmed.trim();
+        }
+      }
+      return {
+        type: "heading",
+        raw: cap[0],
+        depth: cap[1].length,
+        text,
+        tokens: this.lexer.inline(text)
+      };
+    }
+  }
+  hr(src) {
+    const cap = this.rules.block.hr.exec(src);
+    if (cap) {
+      return {
+        type: "hr",
+        raw: rtrim(cap[0], `
+`)
+      };
+    }
+  }
+  blockquote(src) {
+    const cap = this.rules.block.blockquote.exec(src);
+    if (cap) {
+      let lines = rtrim(cap[0], `
+`).split(`
+`);
+      let raw = "";
+      let text = "";
+      const tokens = [];
+      while (lines.length > 0) {
+        let inBlockquote = false;
+        const currentLines = [];
+        let i;
+        for (i = 0;i < lines.length; i++) {
+          if (this.rules.other.blockquoteStart.test(lines[i])) {
+            currentLines.push(lines[i]);
+            inBlockquote = true;
+          } else if (!inBlockquote) {
+            currentLines.push(lines[i]);
+          } else {
+            break;
+          }
+        }
+        lines = lines.slice(i);
+        const currentRaw = currentLines.join(`
+`);
+        const currentText = currentRaw.replace(this.rules.other.blockquoteSetextReplace, `
+    $1`).replace(this.rules.other.blockquoteSetextReplace2, "");
+        raw = raw ? `${raw}
+${currentRaw}` : currentRaw;
+        text = text ? `${text}
+${currentText}` : currentText;
+        const top = this.lexer.state.top;
+        this.lexer.state.top = true;
+        this.lexer.blockTokens(currentText, tokens, true);
+        this.lexer.state.top = top;
+        if (lines.length === 0) {
+          break;
+        }
+        const lastToken = tokens.at(-1);
+        if (lastToken?.type === "code") {
+          break;
+        } else if (lastToken?.type === "blockquote") {
+          const oldToken = lastToken;
+          const newText = oldToken.raw + `
+` + lines.join(`
+`);
+          const newToken = this.blockquote(newText);
+          tokens[tokens.length - 1] = newToken;
+          raw = raw.substring(0, raw.length - oldToken.raw.length) + newToken.raw;
+          text = text.substring(0, text.length - oldToken.text.length) + newToken.text;
+          break;
+        } else if (lastToken?.type === "list") {
+          const oldToken = lastToken;
+          const newText = oldToken.raw + `
+` + lines.join(`
+`);
+          const newToken = this.list(newText);
+          tokens[tokens.length - 1] = newToken;
+          raw = raw.substring(0, raw.length - lastToken.raw.length) + newToken.raw;
+          text = text.substring(0, text.length - oldToken.raw.length) + newToken.raw;
+          lines = newText.substring(tokens.at(-1).raw.length).split(`
+`);
+          continue;
+        }
+      }
+      return {
+        type: "blockquote",
+        raw,
+        tokens,
+        text
+      };
+    }
+  }
+  list(src) {
+    let cap = this.rules.block.list.exec(src);
+    if (cap) {
+      let bull = cap[1].trim();
+      const isordered = bull.length > 1;
+      const list2 = {
+        type: "list",
+        raw: "",
+        ordered: isordered,
+        start: isordered ? +bull.slice(0, -1) : "",
+        loose: false,
+        items: []
+      };
+      bull = isordered ? `\\d{1,9}\\${bull.slice(-1)}` : `\\${bull}`;
+      if (this.options.pedantic) {
+        bull = isordered ? bull : "[*+-]";
+      }
+      const itemRegex = this.rules.other.listItemRegex(bull);
+      let endsWithBlankLine = false;
+      while (src) {
+        let endEarly = false;
+        let raw = "";
+        let itemContents = "";
+        if (!(cap = itemRegex.exec(src))) {
+          break;
+        }
+        if (this.rules.block.hr.test(src)) {
+          break;
+        }
+        raw = cap[0];
+        src = src.substring(raw.length);
+        let line = cap[2].split(`
+`, 1)[0].replace(this.rules.other.listReplaceTabs, (t) => " ".repeat(3 * t.length));
+        let nextLine = src.split(`
+`, 1)[0];
+        let blankLine = !line.trim();
+        let indent = 0;
+        if (this.options.pedantic) {
+          indent = 2;
+          itemContents = line.trimStart();
+        } else if (blankLine) {
+          indent = cap[1].length + 1;
+        } else {
+          indent = cap[2].search(this.rules.other.nonSpaceChar);
+          indent = indent > 4 ? 1 : indent;
+          itemContents = line.slice(indent);
+          indent += cap[1].length;
+        }
+        if (blankLine && this.rules.other.blankLine.test(nextLine)) {
+          raw += nextLine + `
+`;
+          src = src.substring(nextLine.length + 1);
+          endEarly = true;
+        }
+        if (!endEarly) {
+          const nextBulletRegex = this.rules.other.nextBulletRegex(indent);
+          const hrRegex = this.rules.other.hrRegex(indent);
+          const fencesBeginRegex = this.rules.other.fencesBeginRegex(indent);
+          const headingBeginRegex = this.rules.other.headingBeginRegex(indent);
+          const htmlBeginRegex = this.rules.other.htmlBeginRegex(indent);
+          while (src) {
+            const rawLine = src.split(`
+`, 1)[0];
+            let nextLineWithoutTabs;
+            nextLine = rawLine;
+            if (this.options.pedantic) {
+              nextLine = nextLine.replace(this.rules.other.listReplaceNesting, "  ");
+              nextLineWithoutTabs = nextLine;
+            } else {
+              nextLineWithoutTabs = nextLine.replace(this.rules.other.tabCharGlobal, "    ");
+            }
+            if (fencesBeginRegex.test(nextLine)) {
+              break;
+            }
+            if (headingBeginRegex.test(nextLine)) {
+              break;
+            }
+            if (htmlBeginRegex.test(nextLine)) {
+              break;
+            }
+            if (nextBulletRegex.test(nextLine)) {
+              break;
+            }
+            if (hrRegex.test(nextLine)) {
+              break;
+            }
+            if (nextLineWithoutTabs.search(this.rules.other.nonSpaceChar) >= indent || !nextLine.trim()) {
+              itemContents += `
+` + nextLineWithoutTabs.slice(indent);
+            } else {
+              if (blankLine) {
+                break;
+              }
+              if (line.replace(this.rules.other.tabCharGlobal, "    ").search(this.rules.other.nonSpaceChar) >= 4) {
+                break;
+              }
+              if (fencesBeginRegex.test(line)) {
+                break;
+              }
+              if (headingBeginRegex.test(line)) {
+                break;
+              }
+              if (hrRegex.test(line)) {
+                break;
+              }
+              itemContents += `
+` + nextLine;
+            }
+            if (!blankLine && !nextLine.trim()) {
+              blankLine = true;
+            }
+            raw += rawLine + `
+`;
+            src = src.substring(rawLine.length + 1);
+            line = nextLineWithoutTabs.slice(indent);
+          }
+        }
+        if (!list2.loose) {
+          if (endsWithBlankLine) {
+            list2.loose = true;
+          } else if (this.rules.other.doubleBlankLine.test(raw)) {
+            endsWithBlankLine = true;
+          }
+        }
+        let istask = null;
+        let ischecked;
+        if (this.options.gfm) {
+          istask = this.rules.other.listIsTask.exec(itemContents);
+          if (istask) {
+            ischecked = istask[0] !== "[ ] ";
+            itemContents = itemContents.replace(this.rules.other.listReplaceTask, "");
+          }
+        }
+        list2.items.push({
+          type: "list_item",
+          raw,
+          task: !!istask,
+          checked: ischecked,
+          loose: false,
+          text: itemContents,
+          tokens: []
+        });
+        list2.raw += raw;
+      }
+      const lastItem = list2.items.at(-1);
+      if (lastItem) {
+        lastItem.raw = lastItem.raw.trimEnd();
+        lastItem.text = lastItem.text.trimEnd();
+      } else {
+        return;
+      }
+      list2.raw = list2.raw.trimEnd();
+      for (let i = 0;i < list2.items.length; i++) {
+        this.lexer.state.top = false;
+        list2.items[i].tokens = this.lexer.blockTokens(list2.items[i].text, []);
+        if (!list2.loose) {
+          const spacers = list2.items[i].tokens.filter((t) => t.type === "space");
+          const hasMultipleLineBreaks = spacers.length > 0 && spacers.some((t) => this.rules.other.anyLine.test(t.raw));
+          list2.loose = hasMultipleLineBreaks;
+        }
+      }
+      if (list2.loose) {
+        for (let i = 0;i < list2.items.length; i++) {
+          list2.items[i].loose = true;
+        }
+      }
+      return list2;
+    }
+  }
+  html(src) {
+    const cap = this.rules.block.html.exec(src);
+    if (cap) {
+      const token = {
+        type: "html",
+        block: true,
+        raw: cap[0],
+        pre: cap[1] === "pre" || cap[1] === "script" || cap[1] === "style",
+        text: cap[0]
+      };
+      return token;
+    }
+  }
+  def(src) {
+    const cap = this.rules.block.def.exec(src);
+    if (cap) {
+      const tag2 = cap[1].toLowerCase().replace(this.rules.other.multipleSpaceGlobal, " ");
+      const href = cap[2] ? cap[2].replace(this.rules.other.hrefBrackets, "$1").replace(this.rules.inline.anyPunctuation, "$1") : "";
+      const title = cap[3] ? cap[3].substring(1, cap[3].length - 1).replace(this.rules.inline.anyPunctuation, "$1") : cap[3];
+      return {
+        type: "def",
+        tag: tag2,
+        raw: cap[0],
+        href,
+        title
+      };
+    }
+  }
+  table(src) {
+    const cap = this.rules.block.table.exec(src);
+    if (!cap) {
+      return;
+    }
+    if (!this.rules.other.tableDelimiter.test(cap[2])) {
+      return;
+    }
+    const headers = splitCells(cap[1]);
+    const aligns = cap[2].replace(this.rules.other.tableAlignChars, "").split("|");
+    const rows = cap[3]?.trim() ? cap[3].replace(this.rules.other.tableRowBlankLine, "").split(`
+`) : [];
+    const item = {
+      type: "table",
+      raw: cap[0],
+      header: [],
+      align: [],
+      rows: []
+    };
+    if (headers.length !== aligns.length) {
+      return;
+    }
+    for (const align of aligns) {
+      if (this.rules.other.tableAlignRight.test(align)) {
+        item.align.push("right");
+      } else if (this.rules.other.tableAlignCenter.test(align)) {
+        item.align.push("center");
+      } else if (this.rules.other.tableAlignLeft.test(align)) {
+        item.align.push("left");
+      } else {
+        item.align.push(null);
+      }
+    }
+    for (let i = 0;i < headers.length; i++) {
+      item.header.push({
+        text: headers[i],
+        tokens: this.lexer.inline(headers[i]),
+        header: true,
+        align: item.align[i]
+      });
+    }
+    for (const row of rows) {
+      item.rows.push(splitCells(row, item.header.length).map((cell, i) => {
+        return {
+          text: cell,
+          tokens: this.lexer.inline(cell),
+          header: false,
+          align: item.align[i]
+        };
+      }));
+    }
+    return item;
+  }
+  lheading(src) {
+    const cap = this.rules.block.lheading.exec(src);
+    if (cap) {
+      return {
+        type: "heading",
+        raw: cap[0],
+        depth: cap[2].charAt(0) === "=" ? 1 : 2,
+        text: cap[1],
+        tokens: this.lexer.inline(cap[1])
+      };
+    }
+  }
+  paragraph(src) {
+    const cap = this.rules.block.paragraph.exec(src);
+    if (cap) {
+      const text = cap[1].charAt(cap[1].length - 1) === `
+` ? cap[1].slice(0, -1) : cap[1];
+      return {
+        type: "paragraph",
+        raw: cap[0],
+        text,
+        tokens: this.lexer.inline(text)
+      };
+    }
+  }
+  text(src) {
+    const cap = this.rules.block.text.exec(src);
+    if (cap) {
+      return {
+        type: "text",
+        raw: cap[0],
+        text: cap[0],
+        tokens: this.lexer.inline(cap[0])
+      };
+    }
+  }
+  escape(src) {
+    const cap = this.rules.inline.escape.exec(src);
+    if (cap) {
+      return {
+        type: "escape",
+        raw: cap[0],
+        text: cap[1]
+      };
+    }
+  }
+  tag(src) {
+    const cap = this.rules.inline.tag.exec(src);
+    if (cap) {
+      if (!this.lexer.state.inLink && this.rules.other.startATag.test(cap[0])) {
+        this.lexer.state.inLink = true;
+      } else if (this.lexer.state.inLink && this.rules.other.endATag.test(cap[0])) {
+        this.lexer.state.inLink = false;
+      }
+      if (!this.lexer.state.inRawBlock && this.rules.other.startPreScriptTag.test(cap[0])) {
+        this.lexer.state.inRawBlock = true;
+      } else if (this.lexer.state.inRawBlock && this.rules.other.endPreScriptTag.test(cap[0])) {
+        this.lexer.state.inRawBlock = false;
+      }
+      return {
+        type: "html",
+        raw: cap[0],
+        inLink: this.lexer.state.inLink,
+        inRawBlock: this.lexer.state.inRawBlock,
+        block: false,
+        text: cap[0]
+      };
+    }
+  }
+  link(src) {
+    const cap = this.rules.inline.link.exec(src);
+    if (cap) {
+      const trimmedUrl = cap[2].trim();
+      if (!this.options.pedantic && this.rules.other.startAngleBracket.test(trimmedUrl)) {
+        if (!this.rules.other.endAngleBracket.test(trimmedUrl)) {
+          return;
+        }
+        const rtrimSlash = rtrim(trimmedUrl.slice(0, -1), "\\");
+        if ((trimmedUrl.length - rtrimSlash.length) % 2 === 0) {
+          return;
+        }
+      } else {
+        const lastParenIndex = findClosingBracket(cap[2], "()");
+        if (lastParenIndex === -2) {
+          return;
+        }
+        if (lastParenIndex > -1) {
+          const start = cap[0].indexOf("!") === 0 ? 5 : 4;
+          const linkLen = start + cap[1].length + lastParenIndex;
+          cap[2] = cap[2].substring(0, lastParenIndex);
+          cap[0] = cap[0].substring(0, linkLen).trim();
+          cap[3] = "";
+        }
+      }
+      let href = cap[2];
+      let title = "";
+      if (this.options.pedantic) {
+        const link2 = this.rules.other.pedanticHrefTitle.exec(href);
+        if (link2) {
+          href = link2[1];
+          title = link2[3];
+        }
+      } else {
+        title = cap[3] ? cap[3].slice(1, -1) : "";
+      }
+      href = href.trim();
+      if (this.rules.other.startAngleBracket.test(href)) {
+        if (this.options.pedantic && !this.rules.other.endAngleBracket.test(trimmedUrl)) {
+          href = href.slice(1);
+        } else {
+          href = href.slice(1, -1);
+        }
+      }
+      return outputLink(cap, {
+        href: href ? href.replace(this.rules.inline.anyPunctuation, "$1") : href,
+        title: title ? title.replace(this.rules.inline.anyPunctuation, "$1") : title
+      }, cap[0], this.lexer, this.rules);
+    }
+  }
+  reflink(src, links) {
+    let cap;
+    if ((cap = this.rules.inline.reflink.exec(src)) || (cap = this.rules.inline.nolink.exec(src))) {
+      const linkString = (cap[2] || cap[1]).replace(this.rules.other.multipleSpaceGlobal, " ");
+      const link2 = links[linkString.toLowerCase()];
+      if (!link2) {
+        const text = cap[0].charAt(0);
+        return {
+          type: "text",
+          raw: text,
+          text
+        };
+      }
+      return outputLink(cap, link2, cap[0], this.lexer, this.rules);
+    }
+  }
+  emStrong(src, maskedSrc, prevChar = "") {
+    let match = this.rules.inline.emStrongLDelim.exec(src);
+    if (!match)
+      return;
+    if (match[3] && prevChar.match(this.rules.other.unicodeAlphaNumeric))
+      return;
+    const nextChar = match[1] || match[2] || "";
+    if (!nextChar || !prevChar || this.rules.inline.punctuation.exec(prevChar)) {
+      const lLength = [...match[0]].length - 1;
+      let rDelim, rLength, delimTotal = lLength, midDelimTotal = 0;
+      const endReg = match[0][0] === "*" ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd;
+      endReg.lastIndex = 0;
+      maskedSrc = maskedSrc.slice(-1 * src.length + lLength);
+      while ((match = endReg.exec(maskedSrc)) != null) {
+        rDelim = match[1] || match[2] || match[3] || match[4] || match[5] || match[6];
+        if (!rDelim)
+          continue;
+        rLength = [...rDelim].length;
+        if (match[3] || match[4]) {
+          delimTotal += rLength;
+          continue;
+        } else if (match[5] || match[6]) {
+          if (lLength % 3 && !((lLength + rLength) % 3)) {
+            midDelimTotal += rLength;
+            continue;
+          }
+        }
+        delimTotal -= rLength;
+        if (delimTotal > 0)
+          continue;
+        rLength = Math.min(rLength, rLength + delimTotal + midDelimTotal);
+        const lastCharLength = [...match[0]][0].length;
+        const raw = src.slice(0, lLength + match.index + lastCharLength + rLength);
+        if (Math.min(lLength, rLength) % 2) {
+          const text2 = raw.slice(1, -1);
+          return {
+            type: "em",
+            raw,
+            text: text2,
+            tokens: this.lexer.inlineTokens(text2)
+          };
+        }
+        const text = raw.slice(2, -2);
+        return {
+          type: "strong",
+          raw,
+          text,
+          tokens: this.lexer.inlineTokens(text)
+        };
+      }
+    }
+  }
+  codespan(src) {
+    const cap = this.rules.inline.code.exec(src);
+    if (cap) {
+      let text = cap[2].replace(this.rules.other.newLineCharGlobal, " ");
+      const hasNonSpaceChars = this.rules.other.nonSpaceChar.test(text);
+      const hasSpaceCharsOnBothEnds = this.rules.other.startingSpaceChar.test(text) && this.rules.other.endingSpaceChar.test(text);
+      if (hasNonSpaceChars && hasSpaceCharsOnBothEnds) {
+        text = text.substring(1, text.length - 1);
+      }
+      return {
+        type: "codespan",
+        raw: cap[0],
+        text
+      };
+    }
+  }
+  br(src) {
+    const cap = this.rules.inline.br.exec(src);
+    if (cap) {
+      return {
+        type: "br",
+        raw: cap[0]
+      };
+    }
+  }
+  del(src) {
+    const cap = this.rules.inline.del.exec(src);
+    if (cap) {
+      return {
+        type: "del",
+        raw: cap[0],
+        text: cap[2],
+        tokens: this.lexer.inlineTokens(cap[2])
+      };
+    }
+  }
+  autolink(src) {
+    const cap = this.rules.inline.autolink.exec(src);
+    if (cap) {
+      let text, href;
+      if (cap[2] === "@") {
+        text = cap[1];
+        href = "mailto:" + text;
+      } else {
+        text = cap[1];
+        href = text;
+      }
+      return {
+        type: "link",
+        raw: cap[0],
+        text,
+        href,
+        tokens: [
+          {
+            type: "text",
+            raw: text,
+            text
+          }
+        ]
+      };
+    }
+  }
+  url(src) {
+    let cap;
+    if (cap = this.rules.inline.url.exec(src)) {
+      let text, href;
+      if (cap[2] === "@") {
+        text = cap[0];
+        href = "mailto:" + text;
+      } else {
+        let prevCapZero;
+        do {
+          prevCapZero = cap[0];
+          cap[0] = this.rules.inline._backpedal.exec(cap[0])?.[0] ?? "";
+        } while (prevCapZero !== cap[0]);
+        text = cap[0];
+        if (cap[1] === "www.") {
+          href = "http://" + cap[0];
+        } else {
+          href = cap[0];
+        }
+      }
+      return {
+        type: "link",
+        raw: cap[0],
+        text,
+        href,
+        tokens: [
+          {
+            type: "text",
+            raw: text,
+            text
+          }
+        ]
+      };
+    }
+  }
+  inlineText(src) {
+    const cap = this.rules.inline.text.exec(src);
+    if (cap) {
+      const escaped = this.lexer.state.inRawBlock;
+      return {
+        type: "text",
+        raw: cap[0],
+        text: cap[0],
+        escaped
+      };
+    }
+  }
+}
+
+class _Lexer {
+  tokens;
+  options;
+  state;
+  tokenizer;
+  inlineQueue;
+  constructor(options) {
+    this.tokens = [];
+    this.tokens.links = Object.create(null);
+    this.options = options || _defaults;
+    this.options.tokenizer = this.options.tokenizer || new _Tokenizer;
+    this.tokenizer = this.options.tokenizer;
+    this.tokenizer.options = this.options;
+    this.tokenizer.lexer = this;
+    this.inlineQueue = [];
+    this.state = {
+      inLink: false,
+      inRawBlock: false,
+      top: true
+    };
+    const rules = {
+      other,
+      block: block.normal,
+      inline: inline.normal
+    };
+    if (this.options.pedantic) {
+      rules.block = block.pedantic;
+      rules.inline = inline.pedantic;
+    } else if (this.options.gfm) {
+      rules.block = block.gfm;
+      if (this.options.breaks) {
+        rules.inline = inline.breaks;
+      } else {
+        rules.inline = inline.gfm;
+      }
+    }
+    this.tokenizer.rules = rules;
+  }
+  static get rules() {
+    return {
+      block,
+      inline
+    };
+  }
+  static lex(src, options) {
+    const lexer = new _Lexer(options);
+    return lexer.lex(src);
+  }
+  static lexInline(src, options) {
+    const lexer = new _Lexer(options);
+    return lexer.inlineTokens(src);
+  }
+  lex(src) {
+    src = src.replace(other.carriageReturn, `
+`);
+    this.blockTokens(src, this.tokens);
+    for (let i = 0;i < this.inlineQueue.length; i++) {
+      const next = this.inlineQueue[i];
+      this.inlineTokens(next.src, next.tokens);
+    }
+    this.inlineQueue = [];
+    return this.tokens;
+  }
+  blockTokens(src, tokens = [], lastParagraphClipped = false) {
+    if (this.options.pedantic) {
+      src = src.replace(other.tabCharGlobal, "    ").replace(other.spaceLine, "");
+    }
+    while (src) {
+      let token;
+      if (this.options.extensions?.block?.some((extTokenizer) => {
+        if (token = extTokenizer.call({ lexer: this }, src, tokens)) {
+          src = src.substring(token.raw.length);
+          tokens.push(token);
+          return true;
+        }
+        return false;
+      })) {
+        continue;
+      }
+      if (token = this.tokenizer.space(src)) {
+        src = src.substring(token.raw.length);
+        const lastToken = tokens.at(-1);
+        if (token.raw.length === 1 && lastToken !== undefined) {
+          lastToken.raw += `
+`;
+        } else {
+          tokens.push(token);
+        }
+        continue;
+      }
+      if (token = this.tokenizer.code(src)) {
+        src = src.substring(token.raw.length);
+        const lastToken = tokens.at(-1);
+        if (lastToken?.type === "paragraph" || lastToken?.type === "text") {
+          lastToken.raw += `
+` + token.raw;
+          lastToken.text += `
+` + token.text;
+          this.inlineQueue.at(-1).src = lastToken.text;
+        } else {
+          tokens.push(token);
+        }
+        continue;
+      }
+      if (token = this.tokenizer.fences(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.heading(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.hr(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.blockquote(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.list(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.html(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.def(src)) {
+        src = src.substring(token.raw.length);
+        const lastToken = tokens.at(-1);
+        if (lastToken?.type === "paragraph" || lastToken?.type === "text") {
+          lastToken.raw += `
+` + token.raw;
+          lastToken.text += `
+` + token.raw;
+          this.inlineQueue.at(-1).src = lastToken.text;
+        } else if (!this.tokens.links[token.tag]) {
+          this.tokens.links[token.tag] = {
+            href: token.href,
+            title: token.title
+          };
+        }
+        continue;
+      }
+      if (token = this.tokenizer.table(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.lheading(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      let cutSrc = src;
+      if (this.options.extensions?.startBlock) {
+        let startIndex = Infinity;
+        const tempSrc = src.slice(1);
+        let tempStart;
+        this.options.extensions.startBlock.forEach((getStartIndex) => {
+          tempStart = getStartIndex.call({ lexer: this }, tempSrc);
+          if (typeof tempStart === "number" && tempStart >= 0) {
+            startIndex = Math.min(startIndex, tempStart);
+          }
+        });
+        if (startIndex < Infinity && startIndex >= 0) {
+          cutSrc = src.substring(0, startIndex + 1);
+        }
+      }
+      if (this.state.top && (token = this.tokenizer.paragraph(cutSrc))) {
+        const lastToken = tokens.at(-1);
+        if (lastParagraphClipped && lastToken?.type === "paragraph") {
+          lastToken.raw += `
+` + token.raw;
+          lastToken.text += `
+` + token.text;
+          this.inlineQueue.pop();
+          this.inlineQueue.at(-1).src = lastToken.text;
+        } else {
+          tokens.push(token);
+        }
+        lastParagraphClipped = cutSrc.length !== src.length;
+        src = src.substring(token.raw.length);
+        continue;
+      }
+      if (token = this.tokenizer.text(src)) {
+        src = src.substring(token.raw.length);
+        const lastToken = tokens.at(-1);
+        if (lastToken?.type === "text") {
+          lastToken.raw += `
+` + token.raw;
+          lastToken.text += `
+` + token.text;
+          this.inlineQueue.pop();
+          this.inlineQueue.at(-1).src = lastToken.text;
+        } else {
+          tokens.push(token);
+        }
+        continue;
+      }
+      if (src) {
+        const errMsg = "Infinite loop on byte: " + src.charCodeAt(0);
+        if (this.options.silent) {
+          console.error(errMsg);
+          break;
+        } else {
+          throw new Error(errMsg);
+        }
+      }
+    }
+    this.state.top = true;
+    return tokens;
+  }
+  inline(src, tokens = []) {
+    this.inlineQueue.push({ src, tokens });
+    return tokens;
+  }
+  inlineTokens(src, tokens = []) {
+    let maskedSrc = src;
+    let match = null;
+    if (this.tokens.links) {
+      const links = Object.keys(this.tokens.links);
+      if (links.length > 0) {
+        while ((match = this.tokenizer.rules.inline.reflinkSearch.exec(maskedSrc)) != null) {
+          if (links.includes(match[0].slice(match[0].lastIndexOf("[") + 1, -1))) {
+            maskedSrc = maskedSrc.slice(0, match.index) + "[" + "a".repeat(match[0].length - 2) + "]" + maskedSrc.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex);
+          }
+        }
+      }
+    }
+    while ((match = this.tokenizer.rules.inline.anyPunctuation.exec(maskedSrc)) != null) {
+      maskedSrc = maskedSrc.slice(0, match.index) + "++" + maskedSrc.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);
+    }
+    while ((match = this.tokenizer.rules.inline.blockSkip.exec(maskedSrc)) != null) {
+      maskedSrc = maskedSrc.slice(0, match.index) + "[" + "a".repeat(match[0].length - 2) + "]" + maskedSrc.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);
+    }
+    let keepPrevChar = false;
+    let prevChar = "";
+    while (src) {
+      if (!keepPrevChar) {
+        prevChar = "";
+      }
+      keepPrevChar = false;
+      let token;
+      if (this.options.extensions?.inline?.some((extTokenizer) => {
+        if (token = extTokenizer.call({ lexer: this }, src, tokens)) {
+          src = src.substring(token.raw.length);
+          tokens.push(token);
+          return true;
+        }
+        return false;
+      })) {
+        continue;
+      }
+      if (token = this.tokenizer.escape(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.tag(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.link(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.reflink(src, this.tokens.links)) {
+        src = src.substring(token.raw.length);
+        const lastToken = tokens.at(-1);
+        if (token.type === "text" && lastToken?.type === "text") {
+          lastToken.raw += token.raw;
+          lastToken.text += token.text;
+        } else {
+          tokens.push(token);
+        }
+        continue;
+      }
+      if (token = this.tokenizer.emStrong(src, maskedSrc, prevChar)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.codespan(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.br(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.del(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.autolink(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (!this.state.inLink && (token = this.tokenizer.url(src))) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      let cutSrc = src;
+      if (this.options.extensions?.startInline) {
+        let startIndex = Infinity;
+        const tempSrc = src.slice(1);
+        let tempStart;
+        this.options.extensions.startInline.forEach((getStartIndex) => {
+          tempStart = getStartIndex.call({ lexer: this }, tempSrc);
+          if (typeof tempStart === "number" && tempStart >= 0) {
+            startIndex = Math.min(startIndex, tempStart);
+          }
+        });
+        if (startIndex < Infinity && startIndex >= 0) {
+          cutSrc = src.substring(0, startIndex + 1);
+        }
+      }
+      if (token = this.tokenizer.inlineText(cutSrc)) {
+        src = src.substring(token.raw.length);
+        if (token.raw.slice(-1) !== "_") {
+          prevChar = token.raw.slice(-1);
+        }
+        keepPrevChar = true;
+        const lastToken = tokens.at(-1);
+        if (lastToken?.type === "text") {
+          lastToken.raw += token.raw;
+          lastToken.text += token.text;
+        } else {
+          tokens.push(token);
+        }
+        continue;
+      }
+      if (src) {
+        const errMsg = "Infinite loop on byte: " + src.charCodeAt(0);
+        if (this.options.silent) {
+          console.error(errMsg);
+          break;
+        } else {
+          throw new Error(errMsg);
+        }
+      }
+    }
+    return tokens;
+  }
+}
+
+class _Renderer {
+  options;
+  parser;
+  constructor(options) {
+    this.options = options || _defaults;
+  }
+  space(token) {
+    return "";
+  }
+  code({ text, lang, escaped }) {
+    const langString = (lang || "").match(other.notSpaceStart)?.[0];
+    const code = text.replace(other.endingNewline, "") + `
+`;
+    if (!langString) {
+      return "<pre><code>" + (escaped ? code : escape(code, true)) + `</code></pre>
+`;
+    }
+    return '<pre><code class="language-' + escape(langString) + '">' + (escaped ? code : escape(code, true)) + `</code></pre>
+`;
+  }
+  blockquote({ tokens }) {
+    const body = this.parser.parse(tokens);
+    return `<blockquote>
+${body}</blockquote>
+`;
+  }
+  html({ text }) {
+    return text;
+  }
+  heading({ tokens, depth }) {
+    return `<h${depth}>${this.parser.parseInline(tokens)}</h${depth}>
+`;
+  }
+  hr(token) {
+    return `<hr>
+`;
+  }
+  list(token) {
+    const ordered = token.ordered;
+    const start = token.start;
+    let body = "";
+    for (let j = 0;j < token.items.length; j++) {
+      const item = token.items[j];
+      body += this.listitem(item);
+    }
+    const type = ordered ? "ol" : "ul";
+    const startAttr = ordered && start !== 1 ? ' start="' + start + '"' : "";
+    return "<" + type + startAttr + `>
+` + body + "</" + type + `>
+`;
+  }
+  listitem(item) {
+    let itemBody = "";
+    if (item.task) {
+      const checkbox = this.checkbox({ checked: !!item.checked });
+      if (item.loose) {
+        if (item.tokens[0]?.type === "paragraph") {
+          item.tokens[0].text = checkbox + " " + item.tokens[0].text;
+          if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type === "text") {
+            item.tokens[0].tokens[0].text = checkbox + " " + escape(item.tokens[0].tokens[0].text);
+            item.tokens[0].tokens[0].escaped = true;
+          }
+        } else {
+          item.tokens.unshift({
+            type: "text",
+            raw: checkbox + " ",
+            text: checkbox + " ",
+            escaped: true
+          });
+        }
+      } else {
+        itemBody += checkbox + " ";
+      }
+    }
+    itemBody += this.parser.parse(item.tokens, !!item.loose);
+    return `<li>${itemBody}</li>
+`;
+  }
+  checkbox({ checked }) {
+    return "<input " + (checked ? 'checked="" ' : "") + 'disabled="" type="checkbox">';
+  }
+  paragraph({ tokens }) {
+    return `<p>${this.parser.parseInline(tokens)}</p>
+`;
+  }
+  table(token) {
+    let header = "";
+    let cell = "";
+    for (let j = 0;j < token.header.length; j++) {
+      cell += this.tablecell(token.header[j]);
+    }
+    header += this.tablerow({ text: cell });
+    let body = "";
+    for (let j = 0;j < token.rows.length; j++) {
+      const row = token.rows[j];
+      cell = "";
+      for (let k = 0;k < row.length; k++) {
+        cell += this.tablecell(row[k]);
+      }
+      body += this.tablerow({ text: cell });
+    }
+    if (body)
+      body = `<tbody>${body}</tbody>`;
+    return `<table>
+` + `<thead>
+` + header + `</thead>
+` + body + `</table>
+`;
+  }
+  tablerow({ text }) {
+    return `<tr>
+${text}</tr>
+`;
+  }
+  tablecell(token) {
+    const content = this.parser.parseInline(token.tokens);
+    const type = token.header ? "th" : "td";
+    const tag2 = token.align ? `<${type} align="${token.align}">` : `<${type}>`;
+    return tag2 + content + `</${type}>
+`;
+  }
+  strong({ tokens }) {
+    return `<strong>${this.parser.parseInline(tokens)}</strong>`;
+  }
+  em({ tokens }) {
+    return `<em>${this.parser.parseInline(tokens)}</em>`;
+  }
+  codespan({ text }) {
+    return `<code>${escape(text, true)}</code>`;
+  }
+  br(token) {
+    return "<br>";
+  }
+  del({ tokens }) {
+    return `<del>${this.parser.parseInline(tokens)}</del>`;
+  }
+  link({ href, title, tokens }) {
+    const text = this.parser.parseInline(tokens);
+    const cleanHref = cleanUrl(href);
+    if (cleanHref === null) {
+      return text;
+    }
+    href = cleanHref;
+    let out = '<a href="' + href + '"';
+    if (title) {
+      out += ' title="' + escape(title) + '"';
+    }
+    out += ">" + text + "</a>";
+    return out;
+  }
+  image({ href, title, text, tokens }) {
+    if (tokens) {
+      text = this.parser.parseInline(tokens, this.parser.textRenderer);
+    }
+    const cleanHref = cleanUrl(href);
+    if (cleanHref === null) {
+      return escape(text);
+    }
+    href = cleanHref;
+    let out = `<img src="${href}" alt="${text}"`;
+    if (title) {
+      out += ` title="${escape(title)}"`;
+    }
+    out += ">";
+    return out;
+  }
+  text(token) {
+    return "tokens" in token && token.tokens ? this.parser.parseInline(token.tokens) : ("escaped" in token) && token.escaped ? token.text : escape(token.text);
+  }
+}
+
+class _TextRenderer {
+  strong({ text }) {
+    return text;
+  }
+  em({ text }) {
+    return text;
+  }
+  codespan({ text }) {
+    return text;
+  }
+  del({ text }) {
+    return text;
+  }
+  html({ text }) {
+    return text;
+  }
+  text({ text }) {
+    return text;
+  }
+  link({ text }) {
+    return "" + text;
+  }
+  image({ text }) {
+    return "" + text;
+  }
+  br() {
+    return "";
+  }
+}
+
+class _Parser {
+  options;
+  renderer;
+  textRenderer;
+  constructor(options) {
+    this.options = options || _defaults;
+    this.options.renderer = this.options.renderer || new _Renderer;
+    this.renderer = this.options.renderer;
+    this.renderer.options = this.options;
+    this.renderer.parser = this;
+    this.textRenderer = new _TextRenderer;
+  }
+  static parse(tokens, options) {
+    const parser = new _Parser(options);
+    return parser.parse(tokens);
+  }
+  static parseInline(tokens, options) {
+    const parser = new _Parser(options);
+    return parser.parseInline(tokens);
+  }
+  parse(tokens, top = true) {
+    let out = "";
+    for (let i = 0;i < tokens.length; i++) {
+      const anyToken = tokens[i];
+      if (this.options.extensions?.renderers?.[anyToken.type]) {
+        const genericToken = anyToken;
+        const ret = this.options.extensions.renderers[genericToken.type].call({ parser: this }, genericToken);
+        if (ret !== false || !["space", "hr", "heading", "code", "table", "blockquote", "list", "html", "paragraph", "text"].includes(genericToken.type)) {
+          out += ret || "";
+          continue;
+        }
+      }
+      const token = anyToken;
+      switch (token.type) {
+        case "space": {
+          out += this.renderer.space(token);
+          continue;
+        }
+        case "hr": {
+          out += this.renderer.hr(token);
+          continue;
+        }
+        case "heading": {
+          out += this.renderer.heading(token);
+          continue;
+        }
+        case "code": {
+          out += this.renderer.code(token);
+          continue;
+        }
+        case "table": {
+          out += this.renderer.table(token);
+          continue;
+        }
+        case "blockquote": {
+          out += this.renderer.blockquote(token);
+          continue;
+        }
+        case "list": {
+          out += this.renderer.list(token);
+          continue;
+        }
+        case "html": {
+          out += this.renderer.html(token);
+          continue;
+        }
+        case "paragraph": {
+          out += this.renderer.paragraph(token);
+          continue;
+        }
+        case "text": {
+          let textToken = token;
+          let body = this.renderer.text(textToken);
+          while (i + 1 < tokens.length && tokens[i + 1].type === "text") {
+            textToken = tokens[++i];
+            body += `
+` + this.renderer.text(textToken);
+          }
+          if (top) {
+            out += this.renderer.paragraph({
+              type: "paragraph",
+              raw: body,
+              text: body,
+              tokens: [{ type: "text", raw: body, text: body, escaped: true }]
+            });
+          } else {
+            out += body;
+          }
+          continue;
+        }
+        default: {
+          const errMsg = 'Token with "' + token.type + '" type was not found.';
+          if (this.options.silent) {
+            console.error(errMsg);
+            return "";
+          } else {
+            throw new Error(errMsg);
+          }
+        }
+      }
+    }
+    return out;
+  }
+  parseInline(tokens, renderer = this.renderer) {
+    let out = "";
+    for (let i = 0;i < tokens.length; i++) {
+      const anyToken = tokens[i];
+      if (this.options.extensions?.renderers?.[anyToken.type]) {
+        const ret = this.options.extensions.renderers[anyToken.type].call({ parser: this }, anyToken);
+        if (ret !== false || !["escape", "html", "link", "image", "strong", "em", "codespan", "br", "del", "text"].includes(anyToken.type)) {
+          out += ret || "";
+          continue;
+        }
+      }
+      const token = anyToken;
+      switch (token.type) {
+        case "escape": {
+          out += renderer.text(token);
+          break;
+        }
+        case "html": {
+          out += renderer.html(token);
+          break;
+        }
+        case "link": {
+          out += renderer.link(token);
+          break;
+        }
+        case "image": {
+          out += renderer.image(token);
+          break;
+        }
+        case "strong": {
+          out += renderer.strong(token);
+          break;
+        }
+        case "em": {
+          out += renderer.em(token);
+          break;
+        }
+        case "codespan": {
+          out += renderer.codespan(token);
+          break;
+        }
+        case "br": {
+          out += renderer.br(token);
+          break;
+        }
+        case "del": {
+          out += renderer.del(token);
+          break;
+        }
+        case "text": {
+          out += renderer.text(token);
+          break;
+        }
+        default: {
+          const errMsg = 'Token with "' + token.type + '" type was not found.';
+          if (this.options.silent) {
+            console.error(errMsg);
+            return "";
+          } else {
+            throw new Error(errMsg);
+          }
+        }
+      }
+    }
+    return out;
+  }
+}
+
+class _Hooks {
+  options;
+  block;
+  constructor(options) {
+    this.options = options || _defaults;
+  }
+  static passThroughHooks = new Set([
+    "preprocess",
+    "postprocess",
+    "processAllTokens"
+  ]);
+  preprocess(markdown) {
+    return markdown;
+  }
+  postprocess(html2) {
+    return html2;
+  }
+  processAllTokens(tokens) {
+    return tokens;
+  }
+  provideLexer() {
+    return this.block ? _Lexer.lex : _Lexer.lexInline;
+  }
+  provideParser() {
+    return this.block ? _Parser.parse : _Parser.parseInline;
+  }
+}
+
+class Marked {
+  defaults = _getDefaults();
+  options = this.setOptions;
+  parse = this.parseMarkdown(true);
+  parseInline = this.parseMarkdown(false);
+  Parser = _Parser;
+  Renderer = _Renderer;
+  TextRenderer = _TextRenderer;
+  Lexer = _Lexer;
+  Tokenizer = _Tokenizer;
+  Hooks = _Hooks;
+  constructor(...args) {
+    this.use(...args);
+  }
+  walkTokens(tokens, callback) {
+    let values = [];
+    for (const token of tokens) {
+      values = values.concat(callback.call(this, token));
+      switch (token.type) {
+        case "table": {
+          const tableToken = token;
+          for (const cell of tableToken.header) {
+            values = values.concat(this.walkTokens(cell.tokens, callback));
+          }
+          for (const row of tableToken.rows) {
+            for (const cell of row) {
+              values = values.concat(this.walkTokens(cell.tokens, callback));
+            }
+          }
+          break;
+        }
+        case "list": {
+          const listToken = token;
+          values = values.concat(this.walkTokens(listToken.items, callback));
+          break;
+        }
+        default: {
+          const genericToken = token;
+          if (this.defaults.extensions?.childTokens?.[genericToken.type]) {
+            this.defaults.extensions.childTokens[genericToken.type].forEach((childTokens) => {
+              const tokens2 = genericToken[childTokens].flat(Infinity);
+              values = values.concat(this.walkTokens(tokens2, callback));
+            });
+          } else if (genericToken.tokens) {
+            values = values.concat(this.walkTokens(genericToken.tokens, callback));
+          }
+        }
+      }
+    }
+    return values;
+  }
+  use(...args) {
+    const extensions = this.defaults.extensions || { renderers: {}, childTokens: {} };
+    args.forEach((pack) => {
+      const opts = { ...pack };
+      opts.async = this.defaults.async || opts.async || false;
+      if (pack.extensions) {
+        pack.extensions.forEach((ext) => {
+          if (!ext.name) {
+            throw new Error("extension name required");
+          }
+          if ("renderer" in ext) {
+            const prevRenderer = extensions.renderers[ext.name];
+            if (prevRenderer) {
+              extensions.renderers[ext.name] = function(...args2) {
+                let ret = ext.renderer.apply(this, args2);
+                if (ret === false) {
+                  ret = prevRenderer.apply(this, args2);
+                }
+                return ret;
+              };
+            } else {
+              extensions.renderers[ext.name] = ext.renderer;
+            }
+          }
+          if ("tokenizer" in ext) {
+            if (!ext.level || ext.level !== "block" && ext.level !== "inline") {
+              throw new Error("extension level must be 'block' or 'inline'");
+            }
+            const extLevel = extensions[ext.level];
+            if (extLevel) {
+              extLevel.unshift(ext.tokenizer);
+            } else {
+              extensions[ext.level] = [ext.tokenizer];
+            }
+            if (ext.start) {
+              if (ext.level === "block") {
+                if (extensions.startBlock) {
+                  extensions.startBlock.push(ext.start);
+                } else {
+                  extensions.startBlock = [ext.start];
+                }
+              } else if (ext.level === "inline") {
+                if (extensions.startInline) {
+                  extensions.startInline.push(ext.start);
+                } else {
+                  extensions.startInline = [ext.start];
+                }
+              }
+            }
+          }
+          if ("childTokens" in ext && ext.childTokens) {
+            extensions.childTokens[ext.name] = ext.childTokens;
+          }
+        });
+        opts.extensions = extensions;
+      }
+      if (pack.renderer) {
+        const renderer = this.defaults.renderer || new _Renderer(this.defaults);
+        for (const prop in pack.renderer) {
+          if (!(prop in renderer)) {
+            throw new Error(`renderer '${prop}' does not exist`);
+          }
+          if (["options", "parser"].includes(prop)) {
+            continue;
+          }
+          const rendererProp = prop;
+          const rendererFunc = pack.renderer[rendererProp];
+          const prevRenderer = renderer[rendererProp];
+          renderer[rendererProp] = (...args2) => {
+            let ret = rendererFunc.apply(renderer, args2);
+            if (ret === false) {
+              ret = prevRenderer.apply(renderer, args2);
+            }
+            return ret || "";
+          };
+        }
+        opts.renderer = renderer;
+      }
+      if (pack.tokenizer) {
+        const tokenizer = this.defaults.tokenizer || new _Tokenizer(this.defaults);
+        for (const prop in pack.tokenizer) {
+          if (!(prop in tokenizer)) {
+            throw new Error(`tokenizer '${prop}' does not exist`);
+          }
+          if (["options", "rules", "lexer"].includes(prop)) {
+            continue;
+          }
+          const tokenizerProp = prop;
+          const tokenizerFunc = pack.tokenizer[tokenizerProp];
+          const prevTokenizer = tokenizer[tokenizerProp];
+          tokenizer[tokenizerProp] = (...args2) => {
+            let ret = tokenizerFunc.apply(tokenizer, args2);
+            if (ret === false) {
+              ret = prevTokenizer.apply(tokenizer, args2);
+            }
+            return ret;
+          };
+        }
+        opts.tokenizer = tokenizer;
+      }
+      if (pack.hooks) {
+        const hooks = this.defaults.hooks || new _Hooks;
+        for (const prop in pack.hooks) {
+          if (!(prop in hooks)) {
+            throw new Error(`hook '${prop}' does not exist`);
+          }
+          if (["options", "block"].includes(prop)) {
+            continue;
+          }
+          const hooksProp = prop;
+          const hooksFunc = pack.hooks[hooksProp];
+          const prevHook = hooks[hooksProp];
+          if (_Hooks.passThroughHooks.has(prop)) {
+            hooks[hooksProp] = (arg) => {
+              if (this.defaults.async) {
+                return Promise.resolve(hooksFunc.call(hooks, arg)).then((ret2) => {
+                  return prevHook.call(hooks, ret2);
+                });
+              }
+              const ret = hooksFunc.call(hooks, arg);
+              return prevHook.call(hooks, ret);
+            };
+          } else {
+            hooks[hooksProp] = (...args2) => {
+              let ret = hooksFunc.apply(hooks, args2);
+              if (ret === false) {
+                ret = prevHook.apply(hooks, args2);
+              }
+              return ret;
+            };
+          }
+        }
+        opts.hooks = hooks;
+      }
+      if (pack.walkTokens) {
+        const walkTokens = this.defaults.walkTokens;
+        const packWalktokens = pack.walkTokens;
+        opts.walkTokens = function(token) {
+          let values = [];
+          values.push(packWalktokens.call(this, token));
+          if (walkTokens) {
+            values = values.concat(walkTokens.call(this, token));
+          }
+          return values;
+        };
+      }
+      this.defaults = { ...this.defaults, ...opts };
+    });
+    return this;
+  }
+  setOptions(opt) {
+    this.defaults = { ...this.defaults, ...opt };
+    return this;
+  }
+  lexer(src, options) {
+    return _Lexer.lex(src, options ?? this.defaults);
+  }
+  parser(tokens, options) {
+    return _Parser.parse(tokens, options ?? this.defaults);
+  }
+  parseMarkdown(blockType) {
+    const parse = (src, options) => {
+      const origOpt = { ...options };
+      const opt = { ...this.defaults, ...origOpt };
+      const throwError = this.onError(!!opt.silent, !!opt.async);
+      if (this.defaults.async === true && origOpt.async === false) {
+        return throwError(new Error("marked(): The async option was set to true by an extension. Remove async: false from the parse options object to return a Promise."));
+      }
+      if (typeof src === "undefined" || src === null) {
+        return throwError(new Error("marked(): input parameter is undefined or null"));
+      }
+      if (typeof src !== "string") {
+        return throwError(new Error("marked(): input parameter is of type " + Object.prototype.toString.call(src) + ", string expected"));
+      }
+      if (opt.hooks) {
+        opt.hooks.options = opt;
+        opt.hooks.block = blockType;
+      }
+      const lexer = opt.hooks ? opt.hooks.provideLexer() : blockType ? _Lexer.lex : _Lexer.lexInline;
+      const parser = opt.hooks ? opt.hooks.provideParser() : blockType ? _Parser.parse : _Parser.parseInline;
+      if (opt.async) {
+        return Promise.resolve(opt.hooks ? opt.hooks.preprocess(src) : src).then((src2) => lexer(src2, opt)).then((tokens) => opt.hooks ? opt.hooks.processAllTokens(tokens) : tokens).then((tokens) => opt.walkTokens ? Promise.all(this.walkTokens(tokens, opt.walkTokens)).then(() => tokens) : tokens).then((tokens) => parser(tokens, opt)).then((html2) => opt.hooks ? opt.hooks.postprocess(html2) : html2).catch(throwError);
+      }
+      try {
+        if (opt.hooks) {
+          src = opt.hooks.preprocess(src);
+        }
+        let tokens = lexer(src, opt);
+        if (opt.hooks) {
+          tokens = opt.hooks.processAllTokens(tokens);
+        }
+        if (opt.walkTokens) {
+          this.walkTokens(tokens, opt.walkTokens);
+        }
+        let html2 = parser(tokens, opt);
+        if (opt.hooks) {
+          html2 = opt.hooks.postprocess(html2);
+        }
+        return html2;
+      } catch (e) {
+        return throwError(e);
+      }
+    };
+    return parse;
+  }
+  onError(silent, async) {
+    return (e) => {
+      e.message += `
+Please report this to https://github.com/markedjs/marked.`;
+      if (silent) {
+        const msg = "<p>An error occurred:</p><pre>" + escape(e.message + "", true) + "</pre>";
+        if (async) {
+          return Promise.resolve(msg);
+        }
+        return msg;
+      }
+      if (async) {
+        return Promise.reject(e);
+      }
+      throw e;
+    };
+  }
+}
+var markedInstance = new Marked;
+function marked(src, opt) {
+  return markedInstance.parse(src, opt);
+}
+marked.options = marked.setOptions = function(options) {
+  markedInstance.setOptions(options);
+  marked.defaults = markedInstance.defaults;
+  changeDefaults(marked.defaults);
+  return marked;
+};
+marked.getDefaults = _getDefaults;
+marked.defaults = _defaults;
+marked.use = function(...args) {
+  markedInstance.use(...args);
+  marked.defaults = markedInstance.defaults;
+  changeDefaults(marked.defaults);
+  return marked;
+};
+marked.walkTokens = function(tokens, callback) {
+  return markedInstance.walkTokens(tokens, callback);
+};
+marked.parseInline = markedInstance.parseInline;
+marked.Parser = _Parser;
+marked.parser = _Parser.parse;
+marked.Renderer = _Renderer;
+marked.TextRenderer = _TextRenderer;
+marked.Lexer = _Lexer;
+marked.lexer = _Lexer.lex;
+marked.Tokenizer = _Tokenizer;
+marked.Hooks = _Hooks;
+marked.parse = marked;
+var options = marked.options;
+var setOptions = marked.setOptions;
+var use = marked.use;
+var walkTokens = marked.walkTokens;
+var parseInline = marked.parseInline;
+var parser = _Parser.parse;
+var lexer = _Lexer.lex;
+
+// src/markdown.ts
+async function processMarkdownDirectives(template, context, filePath = "") {
+  let output = template;
+  const regex = /@markdown(?:\(([^)]*)\))?([\s\S]*?)@endmarkdown/g;
+  const matches = [];
+  let match;
+  while ((match = regex.exec(template)) !== null) {
+    matches.push({
+      fullMatch: match[0],
+      options: match[1] || "",
+      content: match[2] || "",
+      index: match.index
+    });
+  }
+  for (const { fullMatch, options: options2, content, index } of matches) {
+    try {
+      const optionsObj = {};
+      if (options2) {
+        options2.split(",").forEach((opt) => {
+          const trimmed = opt.trim();
+          if (trimmed)
+            optionsObj[trimmed] = true;
+        });
+      }
+      const markedOptions = {
+        gfm: optionsObj.gfm ?? true,
+        breaks: optionsObj.breaks ?? false,
+        silent: true
+      };
+      const html2 = await marked.parse(content.trim(), markedOptions);
+      output = output.replace(fullMatch, html2);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const errorHtml = createDetailedErrorMessage("Markdown Directive", `Error processing markdown: ${errorMessage}`, filePath, template, index, fullMatch);
+      output = output.replace(fullMatch, errorHtml);
+    }
+  }
+  return output;
+}
+async function markdownDirectiveHandler(content, params, _context, _filePath) {
+  const options2 = {
+    gfm: true,
+    breaks: false,
+    silent: true
+  };
+  params.forEach((param) => {
+    const trimmed = param.trim().replace(/['"]/g, "");
+    if (trimmed === "breaks")
+      options2.breaks = true;
+    if (trimmed === "no-gfm")
+      options2.gfm = false;
+  });
+  return await marked.parse(content.trim(), options2);
+}
+
+// src/middleware.ts
+async function processMiddleware(template, context, filePath, options2, timing) {
+  if (!options2.middleware || options2.middleware.length === 0) {
+    return template;
+  }
+  let output = template;
+  const middlewareToRun = options2.middleware.filter((m) => m.timing === timing);
+  if (middlewareToRun.length === 0) {
+    return output;
+  }
+  for (const middleware of middlewareToRun) {
+    if (!middleware.name || typeof middleware.handler !== "function") {
+      if (options2.debug) {
+        console.warn("Invalid middleware:", middleware);
+      }
+      continue;
+    }
+    try {
+      const result = await middleware.handler(output, context, filePath, options2);
+      if (typeof result === "string") {
+        output = result;
+      } else if (options2.debug) {
+        console.warn(`Middleware ${middleware.name} did not return a string`);
+      }
+    } catch (error) {
+      if (options2.debug) {
+        console.error(`Error in middleware ${middleware.name}:`, error);
+      }
+      if (options2.debug) {
+        const errorMessage = createDetailedErrorMessage("Middleware", `Error in middleware '${middleware.name}': ${error instanceof Error ? error.message : String(error)}`, filePath, template);
+        output = output.replace(/<body[^>]*>/, `$&
+<div style="color:red;background:#ffeeee;padding:10px;border:1px solid #ff0000;margin:10px 0;font-family:monospace;white-space:pre-wrap;">${errorMessage}</div>
+`);
+      }
+    }
+  }
+  return output;
+}
+async function runPreProcessingMiddleware(template, context, filePath, options2) {
+  return processMiddleware(template, context, filePath, options2, "before");
+}
+async function runPostProcessingMiddleware(template, context, filePath, options2) {
+  return processMiddleware(template, context, filePath, options2, "after");
+}
+
+// src/process.ts
+async function processDirectives(template, context, filePath, options2, dependencies) {
+  let output = template;
+  output = output.replace(/\{\{--[\s\S]*?--\}\}/g, "");
+  output = output.replace(/@@/g, "@");
+  output = output.replace(/@\{\{([\s\S]*?)\}\}/g, (_, content) => {
+    return `{{ ${content} }}`;
+  });
+  const stacks = {};
+  output = processStackPushDirectives(output, stacks);
+  const sections = {};
+  let layoutPath = "";
+  const layoutMatch = output.match(/@extends\(\s*['"]([^'"]+)['"]\s*\)/);
+  if (layoutMatch) {
+    layoutPath = layoutMatch[1];
+    output = output.replace(/@extends\(\s*['"]([^'"]+)['"]\s*\)/, "");
+  }
+  output = output.replace(/@section\(\s*['"]([^'"]+)['"]\s*(?:,\s*['"]([^'"]+)['"]\s*)?\)([\s\S]*?)(?:@endsection|@show)/g, (match, name, value, content) => {
+    if (value) {
+      sections[name] = value;
+      return "";
+    }
+    if (content.includes("@parent")) {
+      sections[name] = content.replace("@parent", "<!--PARENT_CONTENT_PLACEHOLDER-->");
+    } else {
+      sections[name] = content.trim();
+    }
+    return "";
+  });
+  context.__sections = sections;
+  output = output.replace(/@yield\(\s*['"]([^'"]+)['"](?:,\s*['"]([^'"]+)['"])?\)/g, (_, name, defaultContent) => {
+    return sections[name] || defaultContent || "";
+  });
+  output = processStackReplacements(output, stacks);
+  if (layoutPath) {
+    try {
+      if (options2.debug) {
+        console.log(`Processing layout: ${layoutPath} for file ${filePath}`);
+      }
+      const layoutFullPath = await resolveTemplatePath(layoutPath, filePath, options2, dependencies);
+      if (!layoutFullPath) {
+        console.warn(`Layout not found: ${layoutPath} (referenced from ${filePath})`);
+        return output;
+      }
+      const layoutContent = await Bun.file(layoutFullPath).text();
+      const nestedLayoutMatch = layoutContent.match(/@extends\(\s*['"]([^'"]+)['"]\s*\)/);
+      if (nestedLayoutMatch) {
+        if (options2.debug) {
+          console.log(`Found nested layout: ${nestedLayoutMatch[1]} in ${layoutFullPath}`);
+        }
+        const layoutSections2 = {};
+        const processedLayout2 = layoutContent.replace(/@section\(\s*['"]([^'"]+)['"]\s*\)([\s\S]*?)(?:@show|@endsection)/g, (_, name, content) => {
+          layoutSections2[name] = content.trim();
+          return "";
+        });
+        for (const [name, content] of Object.entries(layoutSections2)) {
+          if (sections[name] && sections[name].includes("<!--PARENT_CONTENT_PLACEHOLDER-->")) {
+            sections[name] = sections[name].replace("<!--PARENT_CONTENT_PLACEHOLDER-->", content);
+          } else if (!sections[name]) {
+            sections[name] = content;
+          }
+        }
+        const nestedContext = { ...context, __sections: sections };
+        const nestedTemplate = `@extends('${nestedLayoutMatch[1]}')${processedLayout2}`;
+        return await processDirectives(nestedTemplate, nestedContext, layoutFullPath, options2, dependencies);
+      }
+      let processedLayout = processStackPushDirectives(layoutContent, stacks);
+      const layoutSections = {};
+      processedLayout = processedLayout.replace(/@section\(\s*['"]([^'"]+)['"]\s*\)([\s\S]*?)(?:@show|@endsection)/g, (_, name, content) => {
+        layoutSections[name] = content.trim();
+        return `@yield('${name}')`;
+      });
+      processedLayout = processedLayout.replace(/@yield\(\s*['"]([^'"]+)['"]\s*(?:,\s*['"]([^'"]+)['"]\s*)?\)/g, (_, sectionName, defaultContent) => {
+        if (sections[sectionName]) {
+          let sectionContent = sections[sectionName];
+          if (sectionContent.includes("<!--PARENT_CONTENT_PLACEHOLDER-->")) {
+            sectionContent = sectionContent.replace("<!--PARENT_CONTENT_PLACEHOLDER-->", layoutSections[sectionName] || "");
+          }
+          return sectionContent;
+        }
+        return defaultContent || "";
+      });
+      processedLayout = processStackReplacements(processedLayout, stacks);
+      output = await processOtherDirectives(processedLayout, context, layoutFullPath, options2, dependencies);
+      return output;
+    } catch (error) {
+      console.error(`Error processing layout ${layoutPath}:`, error);
+      return `[Error processing layout: ${error instanceof Error ? error.message : String(error)}]`;
+    }
+  }
+  return await processOtherDirectives(output, context, filePath, options2, dependencies);
+}
+async function processOtherDirectives(template, context, filePath, options2, dependencies) {
+  let output = template;
+  output = await runPreProcessingMiddleware(output, context, filePath, options2);
+  output = await processCustomDirectives(output, context, filePath, options2);
+  output = processAuthDirectives(output, context);
+  output = await processTranslateDirective(output, context, filePath, options2);
+  output = await processMarkdownDirectives(output, context, filePath);
+  output = processJsonDirective(output, context);
+  output = processOnceDirective(output);
+  output = processEnvDirective(output, context);
+  output = processIssetEmptyDirectives(output, context);
+  const componentsDir = path3.resolve(path3.dirname(filePath), options2.componentsDir || "components");
+  output = await processComponentDirectives(output, context, filePath, componentsDir, options2, dependencies);
+  output = await processCustomElements(output, context, filePath, componentsDir, options2, dependencies);
+  output = await processIncludes(output, context, filePath, options2, dependencies);
+  output = processConditionals(output, context, filePath);
+  output = processLoops(output, context, filePath);
+  output = processFormDirectives(output, context);
+  output = processErrorDirective(output, context);
+  output = processExpressions(output, context, filePath);
+  output = await runPostProcessingMiddleware(output, context, filePath, options2);
+  return output;
+}
+async function processComponentDirectives(template, context, filePath, componentsDir, options2, dependencies) {
+  let output = template;
+  const processedComponents = new Set;
+  const componentRegex = /@component\s*\(['"]([^'"]+)['"](?:,\s*(\{[^}]*\}))?\)/g;
+  let match;
+  while (match = componentRegex.exec(output)) {
+    const [fullMatch, componentPath, propsString] = match;
+    let props = {};
+    if (propsString) {
+      try {
+        const propsFn = new Function(...Object.keys(context), `return ${propsString}`);
+        props = propsFn(...Object.values(context));
+      } catch (error) {
+        output = output.replace(fullMatch, `[Error parsing component props: ${error.message}]`);
+        continue;
+      }
+    }
+    const processedContent = await renderComponent(componentPath, props, "", componentsDir, context, filePath, options2, processedComponents, dependencies);
+    output = output.replace(fullMatch, processedContent);
+    componentRegex.lastIndex = 0;
+  }
+  return output;
+}
+async function processCustomElements(template, context, filePath, componentsDir, options2, dependencies) {
+  let output = template;
+  const processedComponents = new Set;
+  const kebabSelfClosingRegex = /<([a-z][a-z0-9]*-[a-z0-9-]*)([^>]*?)\s*\/>/g;
+  output = await processTagComponents(kebabSelfClosingRegex, output, false, true);
+  const kebabWithContentRegex = /<([a-z][a-z0-9]*-[a-z0-9-]*)([^>]*)>([\s\S]*?)<\/\1>/g;
+  output = await processTagComponents(kebabWithContentRegex, output, false, false);
+  const pascalCaseMultilineRegex = /<([A-Z][a-zA-Z0-9]*)\s*\n([\s\S]*?)\/>/g;
+  output = await processMultilineTagComponents(pascalCaseMultilineRegex, output, true, true);
+  const pascalCaseSelfClosingRegex = /<([A-Z][a-zA-Z0-9]*)([^>]*?)\s*\/>/g;
+  output = await processTagComponents(pascalCaseSelfClosingRegex, output, true, true);
+  const pascalCaseAllCapsRegex = /<([A-Z][A-Z0-9]+)([^>]*)>([\s\S]*?)<\/\1>/g;
+  output = await processTagComponents(pascalCaseAllCapsRegex, output, true, false);
+  const pascalCaseRegex = /<([A-Z][a-zA-Z0-9]*)([^>]*)>([\s\S]*?)<\/\1>/g;
+  output = await processTagComponents(pascalCaseRegex, output, true, false);
+  return output;
+  async function processMultilineTagComponents(regex, html2, isPascalCase, _isSelfClosing) {
+    let result = html2;
+    let match;
+    while (match = regex.exec(result)) {
+      const fullMatch = match[0];
+      const tagName = match[1];
+      const attributesBlock = match[2] || "";
+      const matchIndex = match.index;
+      let componentPath;
+      if (isPascalCase) {
+        componentPath = tagName.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+      } else {
+        componentPath = tagName;
+      }
+      const props = {};
+      const attrLines = attributesBlock.split(`
+`);
+      for (const line of attrLines) {
+        const trimmedLine = line.trim();
+        if (!trimmedLine)
+          continue;
+        const attrMatch = trimmedLine.match(/([^\s=]+)=["'](.+?)["']/);
+        if (attrMatch) {
+          const [, attrName, attrValue] = attrMatch;
+          props[attrName] = attrValue;
+        }
+      }
+      const processedContent = await renderComponent(componentPath, props, "", componentsDir, context, filePath, options2, processedComponents, dependencies);
+      result = result.substring(0, matchIndex) + processedContent + result.substring(matchIndex + fullMatch.length);
+      regex.lastIndex = 0;
+    }
+    return result;
+  }
+  async function processTagComponents(regex, html2, isPascalCase, isSelfClosing) {
+    let result = html2;
+    let match;
+    while (match = regex.exec(result)) {
+      const fullMatch = match[0];
+      const tagName = match[1];
+      const attributesStr = match[2] || "";
+      const content = isSelfClosing ? "" : match[3] || "";
+      const matchIndex = match.index;
+      let componentPath;
+      if (isPascalCase) {
+        componentPath = tagName.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+      } else {
+        componentPath = tagName;
+      }
+      const props = {};
+      if (attributesStr) {
+        const attrRegex = /(:|v-bind:)?([^\s=]+)(?:=["']([^"']*)["'])?/g;
+        let attrMatch;
+        while (attrMatch = attrRegex.exec(attributesStr)) {
+          const [, bindPrefix, attrName, attrValue] = attrMatch;
+          if (attrName === "class" || attrName.startsWith("on") || attrName === "style" || attrName === "id") {
+            props[attrName] = attrValue !== undefined ? attrValue : true;
+            continue;
+          }
+          if (bindPrefix) {
+            try {
+              const valueFn = new Function(...Object.keys(context), `return ${attrValue}`);
+              props[attrName] = valueFn(...Object.values(context));
+            } catch (error) {
+              console.error(`Error evaluating binding for ${attrName}:`, error);
+              props[attrName] = `[Error evaluating: ${attrValue}]`;
+            }
+          } else {
+            props[attrName] = attrValue !== undefined ? attrValue : true;
+          }
+        }
+      }
+      const isSelfClosingTag = fullMatch.trimEnd().endsWith("/>") || isPascalCase && !fullMatch.includes("</");
+      const processedContent = await renderComponent(componentPath, props, isSelfClosingTag ? "" : content.trim(), componentsDir, context, filePath, options2, processedComponents, dependencies);
+      result = result.substring(0, matchIndex) + processedContent + result.substring(matchIndex + fullMatch.length);
+      regex.lastIndex = 0;
+    }
+    return result;
+  }
+}
+function processJsonDirective(template, context) {
+  return template.replace(/@json\(\s*([^,)]+)(?:,\s*(true|false))?\)/g, (match, dataPath, pretty) => {
+    try {
+      const evalFn = new Function(...Object.keys(context), `
+        try { return ${dataPath.trim()}; } catch (e) { return undefined; }
+      `);
+      const data = evalFn(...Object.values(context));
+      if (pretty === "true") {
+        return JSON.stringify(data, null, 2);
+      }
+      return JSON.stringify(data);
+    } catch (error) {
+      console.error(`Error processing @json directive: ${error}`);
+      return match;
+    }
+  });
+}
+function processOnceDirective(template) {
+  const onceBlocks = new Map;
+  const onceMatches = [];
+  const regex = /@once\s*([\s\S]*?)@endonce/g;
+  let match = regex.exec(template);
+  while (match !== null) {
+    const fullMatch = match[0];
+    const content = match[1];
+    const start = match.index;
+    const end = start + fullMatch.length;
+    onceMatches.push({
+      match: fullMatch,
+      content: content.trim(),
+      start,
+      end
+    });
+    match = regex.exec(template);
+  }
+  const blocksToRemove = new Set;
+  for (let i = 0;i < onceMatches.length; i++) {
+    const { content } = onceMatches[i];
+    if (onceBlocks.has(content)) {
+      blocksToRemove.add(i);
+    } else {
+      onceBlocks.set(content, { content, index: i });
+    }
+  }
+  let result = template;
+  const sortedMatchesToRemove = Array.from(blocksToRemove).map((index) => onceMatches[index]).sort((a, b) => b.start - a.start);
+  for (const { start, end } of sortedMatchesToRemove) {
+    result = result.substring(0, start) + result.substring(end);
+  }
+  result = result.replace(/@once\s*([\s\S]*?)@endonce/g, "$1");
+  return result;
+}
+
+// src/utils.ts
+var componentsCache = new Map;
+async function renderComponent(componentPath, props, slotContent, componentsDir, parentContext, parentFilePath, options2, processedComponents = new Set, dependencies) {
+  const components = processedComponents ?? new Set;
+  if (components.has(componentPath)) {
+    return `[Circular component reference: ${componentPath}]`;
+  }
+  components.add(componentPath);
+  try {
+    let componentFilePath = componentPath;
+    if (!componentPath.endsWith(".stx")) {
+      componentFilePath = `${componentPath}.stx`;
+    }
+    if (!componentFilePath.startsWith("./") && !componentFilePath.startsWith("../")) {
+      let resolvedPath = path4.join(componentsDir, componentFilePath);
+      if (!await fileExists(resolvedPath)) {
+        const defaultComponentsDir = path4.join(path4.dirname(parentFilePath), "components");
+        resolvedPath = path4.join(defaultComponentsDir, componentFilePath);
+        if (!await fileExists(resolvedPath)) {
+          if (options2.componentsDir && await fileExists(path4.join(options2.componentsDir, componentFilePath))) {
+            resolvedPath = path4.join(options2.componentsDir, componentFilePath);
+          }
+        }
+      }
+      componentFilePath = resolvedPath;
+    } else {
+      componentFilePath = path4.resolve(path4.dirname(parentFilePath), componentFilePath);
+    }
+    if (!await fileExists(componentFilePath)) {
+      return `[Error loading component: ENOENT: no such file or directory, open '${componentPath}']`;
+    }
+    dependencies.add(componentFilePath);
+    let componentContent;
+    if (componentsCache.has(componentFilePath)) {
+      componentContent = componentsCache.get(componentFilePath);
+    } else {
+      try {
+        componentContent = await Bun.file(componentFilePath).text();
+        componentsCache.set(componentFilePath, componentContent);
+      } catch (error) {
+        return `[Error loading component: ${error.message}]`;
+      }
+    }
+    const componentContext = {
+      ...parentContext,
+      ...props,
+      slot: slotContent
+    };
+    const scriptMatch = componentContent.match(/<script\b[^>]*>([\s\S]*?)<\/script>/i);
+    const scriptContent = scriptMatch ? scriptMatch[1] : "";
+    if (scriptContent) {
+      await extractVariables(scriptContent, componentContext, componentFilePath);
+    }
+    let templateContent = componentContent;
+    if (scriptMatch) {
+      templateContent = templateContent.replace(/<script\b[^>]*>[\s\S]*?<\/script>/i, "");
+    }
+    if (slotContent && templateContent.includes("{{ text || slot }}")) {
+      templateContent = templateContent.replace(/\{\{\s*text\s*\|\|\s*slot\s*\}\}/g, slotContent);
+    }
+    for (const [key, value] of Object.entries(componentContext)) {
+      if (typeof value === "string") {
+        if (value.includes("<") && value.includes(">") || value.includes("&lt;") || value.includes("&quot;")) {
+          const unescaped = unescapeHtml(value);
+          componentContext[key] = unescaped;
+        }
+      }
+    }
+    const componentOptions = {
+      ...options2,
+      componentsDir: path4.dirname(componentFilePath)
+    };
+    const result = await processDirectives(templateContent, componentContext, componentFilePath, componentOptions, dependencies);
+    return result;
+  } catch (error) {
+    return `[Error processing component: ${error.message}]`;
+  } finally {
+    components.delete(componentPath);
+  }
+}
+async function fileExists(filePath) {
+  try {
+    const stat = await fs3.promises.stat(filePath);
+    return stat.isFile();
+  } catch {
+    return false;
+  }
+}
+async function extractVariables(scriptContent, context, filePath) {
+  try {
+    const scriptFn = new Function("module", "exports", scriptContent);
+    const module = { exports: {} };
+    scriptFn(module, module.exports);
+    const processValues = (obj) => {
+      if (typeof obj !== "object" || obj === null)
+        return obj;
+      const seen = new WeakSet;
+      const innerProcess = (val) => {
+        if (typeof val !== "object" || val === null)
+          return val;
+        if (seen.has(val)) {
+          return "[Circular Reference]";
+        }
+        seen.add(val);
+        if (Array.isArray(val)) {
+          return val.map((item) => innerProcess(item));
+        }
+        const result = {};
+        for (const [key, value] of Object.entries(val)) {
+          result[key] = innerProcess(value);
+        }
+        return result;
+      };
+      return innerProcess(obj);
+    };
+    Object.assign(context, processValues(module.exports));
+  } catch (error) {
+    console.warn(`Failed to execute script as CommonJS module in ${filePath}:`, error);
+    try {
+      const exportPattern = /export\s(const|let|var|function|default)\s([a-zA-Z_$][\w$]*)?(?:\s*=\s*([^;]+))?/g;
+      let match;
+      match = exportPattern.exec(scriptContent);
+      while (match !== null) {
+        const [, type, name, value] = match;
+        if (type === "default") {
+          if (value) {
+            try {
+              const defaultValueFn = new Function(`return ${value}`);
+              const defaultValue = defaultValueFn();
+              if (typeof defaultValue === "object" && defaultValue !== null) {
+                Object.assign(context, defaultValue);
+              }
+            } catch (e) {
+              console.warn(`Failed to process default export in ${filePath}:`, e);
+            }
+          }
+        } else if (name) {
+          try {
+            const extractFn = new Function(`
+              ${type} ${name} = ${value || "undefined"};
+              return ${name};
+            `);
+            context[name] = extractFn();
+          } catch (e) {
+            console.warn(`Failed to process export of ${name} in ${filePath}:`, e);
+          }
+        }
+        match = exportPattern.exec(scriptContent);
+      }
+    } catch (e) {
+      console.warn(`Failed to process ES module exports in ${filePath}:`, e);
+    }
+  }
+  try {
+    const directFn = new Function(`
+      // Execute script content directly but protect against module not defined
+      try {
+        ${scriptContent}
+      } catch (e) {
+        // Ignore module not defined errors
+        if (!e.toString().includes('module is not defined')) {
+          throw e;
+        }
+      }
+
+      // Return all defined variables, scanning window/global scope
+      return Object.fromEntries(
+        Object.getOwnPropertyNames(this)
+          .filter(key =>
+            // Exclude built-in properties and functions
+            !['global', 'globalThis', 'self', 'window', 'console', 'setTimeout', 'setInterval',
+             'Function', 'Object', 'Array', 'String', 'Number', 'Boolean', 'Error'].includes(key) &&
+            // Only include own properties that aren't functions or built-in properties
+            typeof this[key] !== 'function' &&
+            !key.startsWith('_')
+          )
+          .map(key => [key, this[key]])
+      );
+    `);
+    const vars = directFn();
+    Object.entries(vars).forEach(([key, value]) => {
+      if (value !== undefined && !context[key]) {
+        context[key] = value;
+      }
+    });
+  } catch (error) {
+    if (!error.toString().includes("module is not defined") && !error.toString().includes("Unexpected EOF")) {
+      console.warn(`Variable extraction issue in ${filePath}:`, error);
+    }
+  }
+}
+async function resolveTemplatePath(templatePath, currentFilePath, options2, dependencies) {
+  if (options2.debug) {
+    console.log(`Resolving template path: ${templatePath} from ${currentFilePath}`);
+  }
+  const dirPath = path4.dirname(currentFilePath);
+  if (templatePath.startsWith("/")) {
+    const absolutePath = path4.join(process.cwd(), templatePath);
+    if (options2.debug) {
+      console.log(`Checking absolute path: ${absolutePath}`);
+    }
+    if (await fileExists(absolutePath) && dependencies) {
+      dependencies.add(absolutePath);
+    }
+    return absolutePath;
+  }
+  const directPath = path4.join(dirPath, templatePath);
+  if (await fileExists(directPath)) {
+    if (options2.debug) {
+      console.log(`Found direct path: ${directPath}`);
+    }
+    if (dependencies) {
+      dependencies.add(directPath);
+    }
+    return directPath;
+  }
+  if (!templatePath.endsWith(".stx")) {
+    const pathWithExt = `${directPath}.stx`;
+    if (await fileExists(pathWithExt)) {
+      if (options2.debug) {
+        console.log(`Found direct path with extension: ${pathWithExt}`);
+      }
+      if (dependencies) {
+        dependencies.add(pathWithExt);
+      }
+      return pathWithExt;
+    }
+  }
+  let layoutsDir = path4.join(dirPath, "layouts");
+  if (await fileExists(layoutsDir)) {
+    const fromCurrentLayouts = path4.join(layoutsDir, templatePath);
+    if (await fileExists(fromCurrentLayouts)) {
+      if (options2.debug) {
+        console.log(`Found in current layouts dir: ${fromCurrentLayouts}`);
+      }
+      if (dependencies) {
+        dependencies.add(fromCurrentLayouts);
+      }
+      return fromCurrentLayouts;
+    }
+    if (!templatePath.endsWith(".stx")) {
+      const fromCurrentLayoutsWithExt = `${fromCurrentLayouts}.stx`;
+      if (await fileExists(fromCurrentLayoutsWithExt)) {
+        if (options2.debug) {
+          console.log(`Found in current layouts dir with extension: ${fromCurrentLayoutsWithExt}`);
+        }
+        if (dependencies) {
+          dependencies.add(fromCurrentLayoutsWithExt);
+        }
+        return fromCurrentLayoutsWithExt;
+      }
+    }
+  }
+  if (templatePath.startsWith("layouts/") || templatePath.includes("/layouts/")) {
+    const parts = templatePath.split("layouts/");
+    const layoutsPath = path4.join(options2.partialsDir || dirPath, "layouts", parts[1]);
+    if (await fileExists(layoutsPath)) {
+      if (options2.debug) {
+        console.log(`Found in layouts path: ${layoutsPath}`);
+      }
+      if (dependencies) {
+        dependencies.add(layoutsPath);
+      }
+      return layoutsPath;
+    }
+    if (!layoutsPath.endsWith(".stx")) {
+      const layoutsPathWithExt = `${layoutsPath}.stx`;
+      if (await fileExists(layoutsPathWithExt)) {
+        if (options2.debug) {
+          console.log(`Found in layouts path with extension: ${layoutsPathWithExt}`);
+        }
+        if (dependencies) {
+          dependencies.add(layoutsPathWithExt);
+        }
+        return layoutsPathWithExt;
+      }
+    }
+  }
+  if (options2.partialsDir) {
+    layoutsDir = path4.join(options2.partialsDir, "layouts");
+    if (await fileExists(layoutsDir)) {
+      const fromPartialsLayouts = path4.join(layoutsDir, templatePath);
+      if (await fileExists(fromPartialsLayouts)) {
+        if (options2.debug) {
+          console.log(`Found in partials layouts dir: ${fromPartialsLayouts}`);
+        }
+        if (dependencies) {
+          dependencies.add(fromPartialsLayouts);
+        }
+        return fromPartialsLayouts;
+      }
+      if (!templatePath.endsWith(".stx")) {
+        const fromPartialsLayoutsWithExt = `${fromPartialsLayouts}.stx`;
+        if (await fileExists(fromPartialsLayoutsWithExt)) {
+          if (options2.debug) {
+            console.log(`Found in partials layouts dir with extension: ${fromPartialsLayoutsWithExt}`);
+          }
+          if (dependencies) {
+            dependencies.add(fromPartialsLayoutsWithExt);
+          }
+          return fromPartialsLayoutsWithExt;
+        }
+      }
+    }
+  }
+  const viewsPath = options2.partialsDir || path4.join(process.cwd(), "views");
+  const fromRoot = path4.join(viewsPath, templatePath);
+  if (await fileExists(fromRoot)) {
+    if (options2.debug) {
+      console.log(`Found in views path: ${fromRoot}`);
+    }
+    if (dependencies) {
+      dependencies.add(fromRoot);
+    }
+    return fromRoot;
+  }
+  if (!templatePath.endsWith(".stx")) {
+    const fromRootWithExt = `${fromRoot}.stx`;
+    if (await fileExists(fromRootWithExt)) {
+      if (options2.debug) {
+        console.log(`Found in views path with extension: ${fromRootWithExt}`);
+      }
+      if (dependencies) {
+        dependencies.add(fromRootWithExt);
+      }
+      return fromRootWithExt;
+    }
+  }
+  if (dirPath.includes("temp")) {
+    const tempDirLayouts = path4.join(path4.dirname(dirPath), "layouts", templatePath);
+    if (await fileExists(tempDirLayouts)) {
+      if (options2.debug) {
+        console.log(`Found in temp layouts dir: ${tempDirLayouts}`);
+      }
+      if (dependencies) {
+        dependencies.add(tempDirLayouts);
+      }
+      return tempDirLayouts;
+    }
+    if (!templatePath.endsWith(".stx")) {
+      const tempDirLayoutsWithExt = `${tempDirLayouts}.stx`;
+      if (await fileExists(tempDirLayoutsWithExt)) {
+        if (options2.debug) {
+          console.log(`Found in temp layouts dir with extension: ${tempDirLayoutsWithExt}`);
+        }
+        if (dependencies) {
+          dependencies.add(tempDirLayoutsWithExt);
+        }
+        return tempDirLayoutsWithExt;
+      }
+    }
+  }
+  if (options2.debug) {
+    console.warn(`Template not found after trying all paths: ${templatePath} (referenced from ${currentFilePath})`);
+  } else {
+    console.warn(`Template not found: ${templatePath} (referenced from ${currentFilePath})`);
+  }
+  return null;
+}
+function getSourceLineInfo(template, errorPosition, errorPattern) {
+  let lineNumber = 0;
+  let lineContent = "";
+  let context = "";
+  try {
+    if (typeof errorPosition === "number" && errorPosition >= 0) {
+      const lines = template.split(`
+`);
+      let currentPos = 0;
+      for (let i = 0;i < lines.length; i++) {
+        currentPos += lines[i].length + 1;
+        if (currentPos >= errorPosition) {
+          lineNumber = i + 1;
+          lineContent = lines[i].trim();
+          const start = Math.max(0, i - 2);
+          const end = Math.min(lines.length, i + 3);
+          context = lines.slice(start, end).map((line, idx) => {
+            const contextLineNum = start + idx + 1;
+            const marker = contextLineNum === lineNumber ? "> " : "  ";
+            return `${marker}${contextLineNum}: ${line}`;
+          }).join(`
+`);
+          break;
+        }
+      }
+    } else if (errorPattern) {
+      const patternPos = template.indexOf(errorPattern);
+      if (patternPos >= 0) {
+        return getSourceLineInfo(template, patternPos);
+      }
+    }
+  } catch (_err) {}
+  return { lineNumber, lineContent, context };
+}
+function createDetailedErrorMessage(errorType, errorMessage, filePath, template, errorPosition, errorPattern) {
+  const { lineNumber, context } = getSourceLineInfo(template, errorPosition, errorPattern);
+  let detailedMessage = `[${errorType} Error`;
+  if (lineNumber > 0) {
+    detailedMessage += ` at line ${lineNumber}`;
+  }
+  detailedMessage += ` in ${filePath.split("/").pop()}]`;
+  detailedMessage += `: ${errorMessage}`;
+  if (context) {
+    detailedMessage += `
+
+Context:
+${context}`;
+  }
+  return detailedMessage;
+}
+
+// src/conditionals.ts
+function processConditionals(template, context, filePath) {
+  let output = template;
+  output = output.replace(/@unless\s*\(([^)]+)\)([\s\S]*?)@endunless/g, (_, condition, content) => {
+    return `@if (!(${condition}))${content}@endif`;
+  });
+  output = processIssetEmptyDirectives(output, context, filePath);
+  output = processEnvDirective(output, context, filePath);
+  output = processAuthDirectives(output, context);
+  const processIfStatements = () => {
+    let hasMatches = false;
+    output = output.replace(/@if\s*\(([^)]+)\)([\s\S]*?)@endif/g, (match, condition, content, offset) => {
+      hasMatches = true;
+      try {
+        const conditionFn = new Function(...Object.keys(context), `return ${condition}`);
+        const result = conditionFn(...Object.values(context));
+        if (result) {
+          const elseParts = content.split(/@else(?:if\s*\([^)]+\))?/);
+          return elseParts[0];
+        } else {
+          const elseifMatches = content.match(/@elseif\s*\(([^)]+)\)([\s\S]*?)(?:@elseif|@else|$)/);
+          if (elseifMatches) {
+            try {
+              const elseifFn = new Function(...Object.keys(context), `return ${elseifMatches[1]}`);
+              if (elseifFn(...Object.values(context))) {
+                return elseifMatches[2];
+              }
+            } catch (error) {
+              return createDetailedErrorMessage("Directive", `Error in @elseif(${elseifMatches[1]}): ${error instanceof Error ? error.message : String(error)}`, filePath, template, offset + match.indexOf("@elseif"), `@elseif(${elseifMatches[1]})`);
+            }
+          }
+          const elseMatch = content.match(/@else([\s\S]*?)(?:@elseif|$)/);
+          if (elseMatch) {
+            return elseMatch[1];
+          }
+          return "";
+        }
+      } catch (error) {
+        return createDetailedErrorMessage("Directive", `Error in @if(${condition}): ${error instanceof Error ? error.message : String(error)}`, filePath, template, offset, `@if(${condition})`);
+      }
+    });
+    return hasMatches;
+  };
+  while (processIfStatements()) {}
+  return output;
+}
+function processAuthDirectives(template, context) {
+  let output = template;
+  output = output.replace(/@auth\s*(?:\((.*?)\)\s*)?\n([\s\S]*?)(?:@else\s*\n([\s\S]*?))?@endauth/g, (_, guard, content, elseContent) => {
+    const isAuthenticated = guard ? evaluateAuthExpression(`auth?.check && auth?.user?.[${guard}]`, context) : evaluateAuthExpression("auth?.check", context);
+    return isAuthenticated ? content : elseContent || "";
+  });
+  output = output.replace(/@guest\s*(?:\((.*?)\)\s*)?\n([\s\S]*?)(?:@else\s*\n([\s\S]*?))?@endguest/g, (_, guard, content, elseContent) => {
+    const isGuest = guard ? evaluateAuthExpression(`!auth?.check || !auth?.user?.[${guard}]`, context) : evaluateAuthExpression("!auth?.check", context);
+    return isGuest ? content : elseContent || "";
+  });
+  output = output.replace(/@can\('([^']*)'(?:,\s*'([^']*)')?(?:,\s*([^)]*))?\)\s*\n([\s\S]*?)(?:@elsecan\('([^']*)'(?:,\s*'([^']*)')?(?:,\s*([^)]*))?\)\s*\n([\s\S]*?))?(?:@else\s*\n([\s\S]*?))?@endcan/g, (_, ability, type, id, content, elseAbility, elseType, elseId, elseContent, finalElseContent) => {
+    let can = false;
+    if (context.userCan && typeof context.userCan[ability] === "boolean") {
+      can = context.userCan[ability];
+    } else 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);
+        }
+        can = context.permissions.check(...args);
+      } catch {
+        can = false;
+      }
+    }
+    if (can) {
+      return content;
+    } else if (elseAbility) {
+      let elseCan = false;
+      if (context.userCan && typeof context.userCan[elseAbility] === "boolean") {
+        elseCan = context.userCan[elseAbility];
+      } else if (context.permissions?.check && typeof context.permissions.check === "function") {
+        try {
+          const args = [elseAbility];
+          if (elseType)
+            args.push(elseType);
+          if (elseId) {
+            const elseIdValue = evaluateAuthExpression(elseId, context);
+            args.push(elseIdValue);
+          }
+          elseCan = context.permissions.check(...args);
+        } catch {
+          elseCan = false;
+        }
+      }
+      return elseCan ? elseContent : finalElseContent || "";
+    } else {
+      return finalElseContent || "";
+    }
+  });
+  output = output.replace(/@cannot\('([^']*)'(?:,\s*'([^']*)')?(?:,\s*([^)]*))?\)\s*\n([\s\S]*?)(?:@elsecannot\('([^']*)'(?:,\s*'([^']*)')?(?:,\s*([^)]*))?\)\s*\n([\s\S]*?))?(?:@else\s*\n([\s\S]*?))?@endcannot/g, (_, ability, type, id, content, elseAbility, elseType, elseId, elseContent, finalElseContent) => {
+    let cannot = true;
+    if (context.userCan && typeof context.userCan[ability] === "boolean") {
+      cannot = !context.userCan[ability];
+    } else 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);
+        }
+        cannot = !context.permissions.check(...args);
+      } catch {
+        cannot = true;
+      }
+    }
+    if (cannot) {
+      return content;
+    } else if (elseAbility) {
+      let elseCannot = true;
+      if (context.userCan && typeof context.userCan[elseAbility] === "boolean") {
+        elseCannot = !context.userCan[elseAbility];
+      } else if (context.permissions?.check && typeof context.permissions.check === "function") {
+        try {
+          const args = [elseAbility];
+          if (elseType)
+            args.push(elseType);
+          if (elseId) {
+            const elseIdValue = evaluateAuthExpression(elseId, context);
+            args.push(elseIdValue);
+          }
+          elseCannot = !context.permissions.check(...args);
+        } catch {
+          elseCannot = true;
+        }
+      }
+      return elseCannot ? elseContent : finalElseContent || "";
+    } else {
+      return finalElseContent || "";
+    }
+  });
+  return output;
+}
+function processIssetEmptyDirectives(template, context, filePath) {
+  let result = template;
+  result = result.replace(/@isset\(([^)]+)\)((?:.|\n)*?)(?:@else((?:.|\n)*?))?@endisset/g, (match, variable, content, elseContent, offset) => {
+    try {
+      const value = evaluateAuthExpression(variable.trim(), context);
+      if (value !== undefined && value !== null) {
+        return content;
+      }
+      return elseContent || "";
+    } catch (error) {
+      if (filePath) {
+        return createDetailedErrorMessage("Directive", `Error processing @isset directive: ${error.message}`, filePath, template, offset, match);
+      } else {
+        console.error(`Error processing @isset directive:`, error);
+        return match;
+      }
+    }
+  });
+  result = result.replace(/@empty\(([^)]+)\)((?:.|\n)*?)(?:@else((?:.|\n)*?))?@endempty/g, (match, variable, content, elseContent, offset) => {
+    try {
+      const value = evaluateAuthExpression(variable.trim(), context);
+      const isEmpty = value === undefined || value === null || value === "" || Array.isArray(value) && value.length === 0 || typeof value === "object" && value !== null && Object.keys(value).length === 0;
+      if (isEmpty) {
+        return content;
+      }
+      return elseContent || "";
+    } catch (error) {
+      if (filePath) {
+        return createDetailedErrorMessage("Directive", `Error processing @empty directive: ${error.message}`, filePath, template, offset, match);
+      } else {
+        console.error(`Error processing @empty directive:`, error);
+        return match;
+      }
+    }
+  });
+  return result;
+}
+function processEnvDirective(template, context, filePath) {
+  const result = template;
+  const envPattern = /@env\((['"]?)(.*?)\1\)((?:.|\n)*?)(?:@elseenv\((['"]?)(.*?)\4\)((?:.|\n)*?))?(?:@else((?:.|\n)*?))?@endenv/g;
+  return result.replace(envPattern, (match, quote1, envValue, content, quote2, elseEnvValue, elseEnvContent, elseContent, offset) => {
+    try {
+      const currentEnv = context.NODE_ENV || "development";
+      let envArray = [];
+      if (envValue.startsWith("[") && envValue.endsWith("]")) {
+        const arrayContent = envValue.slice(1, -1).trim();
+        envArray = arrayContent.split(",").map((e) => e.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean);
+      } else {
+        envArray = [envValue];
+      }
+      if (envArray.includes(currentEnv)) {
+        return content;
+      }
+      if (elseEnvValue && elseEnvContent) {
+        let elseEnvArray = [];
+        if (elseEnvValue.startsWith("[") && elseEnvValue.endsWith("]")) {
+          const arrayContent = elseEnvValue.slice(1, -1).trim();
+          elseEnvArray = arrayContent.split(",").map((e) => e.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean);
+        } else {
+          elseEnvArray = [elseEnvValue];
+        }
+        if (elseEnvArray.includes(currentEnv)) {
+          return elseEnvContent;
+        }
+      }
+      return elseContent || "";
+    } catch (error) {
+      if (filePath) {
+        return createDetailedErrorMessage("Directive", `Error processing @env directive: ${error.message}`, filePath, template, offset, match);
+      } else {
+        console.error(`Error processing @env directive:`, error);
+        return match;
+      }
+    }
+  });
+}
+
+// src/loops.ts
+function processLoops(template, context, filePath) {
+  let output = template;
+  output = output.replace(/@forelse\s*\(([^)]+)as([^)]+)\)([\s\S]*?)@empty([\s\S]*?)@endforelse/g, (match, arrayExpr, itemVar, content, emptyContent, offset) => {
+    try {
+      const arrayFn = new Function(...Object.keys(context), `return ${arrayExpr.trim()}`);
+      const array = arrayFn(...Object.values(context));
+      if (!Array.isArray(array) || array.length === 0) {
+        return emptyContent;
+      }
+      return `@foreach (${arrayExpr.trim()} as ${itemVar.trim()})${content}@endforeach`;
+    } catch (error) {
+      return createDetailedErrorMessage("Directive", `Error in @forelse(${arrayExpr.trim()} as ${itemVar.trim()}): ${error instanceof Error ? error.message : String(error)}`, filePath, template, offset, match);
+    }
+  });
+  const processForeachLoops = () => {
+    let hasMatches = false;
+    output = output.replace(/@foreach\s*\(([^)]+)as([^)]+)\)([\s\S]*?)@endforeach/g, (match, arrayExpr, itemVar, content, offset) => {
+      hasMatches = true;
+      try {
+        const arrayFn = new Function(...Object.keys(context), `return ${arrayExpr.trim()}`);
+        const array = arrayFn(...Object.values(context));
+        if (!Array.isArray(array)) {
+          return createDetailedErrorMessage("Directive", `Error in @foreach: ${arrayExpr.trim()} is not an array`, filePath, template, offset, match);
+        }
+        let result = "";
+        for (let index = 0;index < array.length; index++) {
+          const item = array[index];
+          const itemName = itemVar.trim();
+          const itemContext = {
+            ...context,
+            [itemName]: item,
+            loop: {
+              index,
+              iteration: index + 1,
+              first: index === 0,
+              last: index === array.length - 1,
+              count: array.length
+            }
+          };
+          let processedContent = content;
+          processedContent = processConditionals(processedContent, itemContext, filePath);
+          processedContent = processExpressions(processedContent, itemContext, filePath);
+          result += processedContent;
+        }
+        return result;
+      } catch (error) {
+        return createDetailedErrorMessage("Directive", `Error in @foreach(${arrayExpr.trim()} as ${itemVar.trim()}): ${error instanceof Error ? error.message : String(error)}`, filePath, template, offset, match);
+      }
+    });
+    return hasMatches;
+  };
+  let iterations = 0;
+  const MAX_ITERATIONS = 10;
+  while (processForeachLoops() && iterations < MAX_ITERATIONS) {
+    iterations++;
+  }
+  output = output.replace(/@for\s*\(([^)]+)\)([\s\S]*?)@endfor/g, (match, forExpr, content, offset) => {
+    try {
+      const loopKeys = Object.keys(context);
+      const loopValues = Object.values(context);
+      const loopFn = new Function(...loopKeys, `
+        let result = '';
+        for (${forExpr}) {
+          result += \`${content.replace(/`/g, "\\`").replace(/\{\{([^}]+)\}\}/g, (match2, expr) => {
+        return `\${${expr}}`;
+      })}\`;
+        }
+        return result;
+      `);
+      return loopFn(...loopValues);
+    } catch (error) {
+      return createDetailedErrorMessage("Directive", `Error in @for(${forExpr}): ${error instanceof Error ? error.message : String(error)}`, filePath, template, offset, match);
+    }
+  });
+  output = output.replace(/@while\s*\(([^)]+)\)([\s\S]*?)@endwhile/g, (match, condition, content, offset) => {
+    try {
+      const loopKeys = Object.keys(context);
+      const loopValues = Object.values(context);
+      const whileFn = new Function(...loopKeys, `
+        let result = '';
+        let maxIterations = 1000; // Safety limit
+        let counter = 0;
+        while (${condition} && counter < maxIterations) {
+          counter++;
+          result += \`${content.replace(/`/g, "\\`").replace(/\{\{([^}]+)\}\}/g, (match2, expr) => {
+        return `\${${expr}}`;
+      })}\`;
+        }
+        if (counter >= maxIterations) {
+          result += '[Error: Maximum iterations exceeded in while loop]';
+        }
+        return result;
+      `);
+      return whileFn(...loopValues);
+    } catch (error) {
+      return createDetailedErrorMessage("Directive", `Error in @while(${condition}): ${error instanceof Error ? error.message : String(error)}`, filePath, template, offset, match);
+    }
+  });
+  return output;
+}
+export {
+  processLoops
+};
+
+export { evaluateAuthExpression, setGlobalContext, defaultFilters, escapeHtml, processExpressions, applyFilters, evaluateExpression, unescapeHtml, processCustomDirectives, processForms, processBasicFormDirectives, processFormInputDirectives, processErrorDirective, processFormDirectives, loadTranslation, getTranslation, processTranslateDirective, createTranslateFilter, processLoops, partialsCache, processIncludes, processStackPushDirectives, processStackReplacements, processMarkdownDirectives, markdownDirectiveHandler, processMiddleware, runPreProcessingMiddleware, runPostProcessingMiddleware, processDirectives, processJsonDirective, processOnceDirective, renderComponent, fileExists, extractVariables, resolveTemplatePath, getSourceLineInfo, createDetailedErrorMessage };