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

package/dist/expressions.js

@@ -0,0 +1,719 @@
+import { stripCommentsAndLiterals } from "./strip-literals.js";
+import { createSafeFunction, isExpressionSafe, safeEvaluate } from "./safe-evaluator.js";
+import { createDetailedErrorMessage } from "./utils.js";
+import { createPlaceholder } from "./placeholder.js";
+import { maskAtElementPosition, matchScriptElement, matchStyleElement, restoreStashedScripts, stashScriptElements } from "./html-masking.js";
+import { importsSignalDeclarations } from "./imported-signals.js";
+const customFilters = {}, translateRegexCache = new Map;
+function getTranslateRegex(key) {
+  let re = translateRegexCache.get(key);
+  if (!re) {
+    const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    re = new RegExp(`:${escaped}(?!\\w)`, "g");
+    translateRegexCache.set(key, re);
+  }
+  re.lastIndex = 0;
+  return re;
+}
+export const defaultFilters = {
+  uppercase: (value, _context) => {
+    return value !== void 0 && value !== null ? String(value).toUpperCase() : "";
+  },
+  lowercase: (value, _context) => {
+    return value !== void 0 && value !== null ? String(value).toLowerCase() : "";
+  },
+  capitalize: (value, _context) => {
+    if (value === void 0 || value === null)
+      return "";
+    const str = String(value);
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  },
+  number: (value, _context, decimals = 0) => {
+    if (value === void 0 || value === null)
+      return "";
+    try {
+      const numValue = Number(value);
+      return Number.isNaN(numValue) ? "" : numValue.toFixed(Number.parseInt(String(decimals), 10));
+    } catch {
+      return "";
+    }
+  },
+  fmt: (value, _context, locale = "en-US") => {
+    if (value === void 0 || value === null)
+      return "";
+    try {
+      const numValue = Number(value);
+      if (Number.isNaN(numValue))
+        return String(value);
+      return numValue.toLocaleString(locale);
+    } catch {
+      return String(value);
+    }
+  },
+  join: (value, _context, separator = ",") => {
+    if (!Array.isArray(value))
+      return "";
+    return value.join(String(separator));
+  },
+  escape: (value, _context) => {
+    if (value === void 0 || value === null)
+      return "";
+    return escapeHtmlValue(String(value));
+  },
+  translate: (value, context, params = {}) => {
+    if (!context || !context.__translations)
+      return value;
+    const translations = context.__translations, fallbackToKey = context.__i18nConfig?.fallbackToKey ?? !0, parts = String(value).split(".");
+    let translation = translations;
+    for (const part of parts) {
+      if (translation === void 0 || translation === null)
+        break;
+      translation = translation[part];
+    }
+    if (translation === void 0 || translation === null)
+      return fallbackToKey ? value : "";
+    let result = String(translation);
+    Object.entries(params).forEach(([paramKey, paramValue]) => {
+      result = result.replace(getTranslateRegex(paramKey), String(paramValue));
+    });
+    return result;
+  },
+  t: (value, context, params = {}) => {
+    return defaultFilters.translate(value, context, params);
+  },
+  truncate: (value, _context, length = 50, suffix = "...") => {
+    if (value === void 0 || value === null)
+      return "";
+    const str = String(value);
+    if (str.length <= length)
+      return str;
+    if (length <= suffix.length)
+      return suffix.substring(0, length);
+    return str.substring(0, length - suffix.length) + suffix;
+  },
+  date: (value, _context, format = "short", locale = "en-US") => {
+    if (value === void 0 || value === null)
+      return "";
+    try {
+      const date = value instanceof Date ? value : new Date(value);
+      if (Number.isNaN(date.getTime()))
+        return String(value);
+      const formatOptions = {
+        short: { dateStyle: "short" },
+        medium: { dateStyle: "medium" },
+        long: { dateStyle: "long" },
+        full: { dateStyle: "full" },
+        time: { timeStyle: "short" },
+        datetime: { dateStyle: "short", timeStyle: "short" },
+        iso: {}
+      };
+      if (format === "iso")
+        return date.toISOString();
+      return new Intl.DateTimeFormat(locale, formatOptions[format] || formatOptions.short).format(date);
+    } catch {
+      return String(value);
+    }
+  },
+  currency: (value, _context, currencyCode = "USD", locale = "en-US") => {
+    if (value === void 0 || value === null)
+      return "";
+    try {
+      const num = Number(value);
+      if (Number.isNaN(num))
+        return String(value);
+      return new Intl.NumberFormat(locale, {
+        style: "currency",
+        currency: currencyCode
+      }).format(num);
+    } catch {
+      return String(value);
+    }
+  },
+  pluralize: (value, _context, singular, plural) => {
+    const count = Number(value);
+    if (Number.isNaN(count))
+      return singular;
+    const pluralForm = plural || `${singular}s`;
+    return count === 1 ? singular : pluralForm;
+  },
+  first: (value, _context) => {
+    if (value === void 0 || value === null)
+      return "";
+    if (Array.isArray(value))
+      return value.length === 0 ? "" : value[0];
+    return String(value).charAt(0);
+  },
+  last: (value, _context) => {
+    if (value === void 0 || value === null)
+      return "";
+    if (Array.isArray(value))
+      return value.length === 0 ? "" : value[value.length - 1];
+    const str = String(value);
+    return str.charAt(str.length - 1);
+  },
+  length: (value, _context) => {
+    if (value === void 0 || value === null)
+      return 0;
+    if (Array.isArray(value) || typeof value === "string")
+      return value.length;
+    if (value instanceof Map || value instanceof Set)
+      return value.size;
+    if (typeof value === "object")
+      return Object.keys(value).length;
+    return 0;
+  },
+  json: (value, _context, pretty = !1) => {
+    if (value === void 0)
+      return "undefined";
+    if (value === null)
+      return "null";
+    try {
+      return pretty ? JSON.stringify(value, null, 2) : JSON.stringify(value);
+    } catch {
+      return String(value);
+    }
+  },
+  default: (value, _context, defaultValue = "") => {
+    return value === void 0 || value === null || value === "" ? defaultValue : value;
+  },
+  reverse: (value, _context) => {
+    if (value === void 0 || value === null)
+      return "";
+    if (Array.isArray(value))
+      return [...value].reverse();
+    return String(value).split("").reverse().join("");
+  },
+  slice: (value, _context, start = 0, end) => {
+    if (value === void 0 || value === null)
+      return "";
+    if (Array.isArray(value) || typeof value === "string")
+      return value.slice(start, end);
+    return value;
+  },
+  replace: (value, _context, search, replacement = "") => {
+    if (value === void 0 || value === null)
+      return "";
+    const escapedSearch = search.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return String(value).replace(new RegExp(escapedSearch, "g"), () => replacement);
+  },
+  stripTags: (value, _context) => {
+    if (value === void 0 || value === null)
+      return "";
+    return String(value).replace(/<[^>]*>/g, "");
+  },
+  urlencode: (value, _context) => {
+    if (value === void 0 || value === null)
+      return "";
+    return encodeURIComponent(String(value));
+  },
+  abs: (value, _context) => {
+    const num = Number(value);
+    return Number.isNaN(num) ? 0 : Math.abs(num);
+  },
+  round: (value, _context, decimals = 0) => {
+    const num = Number(value);
+    if (Number.isNaN(num))
+      return 0;
+    const factor = 10 ** decimals;
+    return Math.round(num * factor) / factor;
+  }
+};
+export function registerFilter(name, fn) {
+  if (name in defaultFilters)
+    console.warn(`Filter "${name}" already exists as a built-in filter. Custom filter will take precedence.`);
+  customFilters[name] = fn;
+}
+export function registerFilters(filters) {
+  for (const [name, fn] of Object.entries(filters))
+    registerFilter(name, fn);
+}
+export function getAllFilters() {
+  return { ...defaultFilters, ...customFilters };
+}
+export function clearCustomFilters() {
+  for (const key of Object.keys(customFilters))
+    delete customFilters[key];
+}
+export function escapeHtml(unsafe) {
+  return unsafe.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+export function escapeHtmlValue(unsafe) {
+  return escapeHtml(unsafe).replace(/\{{2,}/g, (match) => joinBraces(match.length)).replace(/\{(?=!)/g, `&#123;${WORD_JOINER}`);
+}
+const WORD_JOINER = "&#8288;";
+function joinBraces(length) {
+  return Array.from({ length }, () => "&#123;").join(WORD_JOINER);
+}
+export function usesSignalsInScript(template, filePath) {
+  const { scripts } = stashScriptElements(template);
+  for (const script of scripts) {
+    const match = script.match(/^<script\b([^>]*)>([\s\S]*?)<\/script\s*>$/i);
+    if (!match || /\bserver\b|\bsrc\s*=/.test(match[1]))
+      continue;
+    const content = match[2];
+    if (/\b(state|derived|effect|ref|reactive|computed|watch|watchEffect)\s*(?:<[^>]*>)?\s*\(/.test(content))
+      return !0;
+    if (importsSignalDeclarations(content, filePath))
+      return !0;
+  }
+  if (/@(if|for|show)\s*=\s*["'][^"']*\(\s*\)/.test(template))
+    return !0;
+  if (/@for\s*=\s*["'][^"']*\s+(?:in|of)\s+[^"']*\(\s*\)/.test(template))
+    return !0;
+  if (/(?:^|[\s"'])(?::|x-)(?:for|if|else-if|else|show|text|html|model|bind)\b/.test(template))
+    return !0;
+  return !1;
+}
+function expressionUsesOnlyContextVars(expr, context) {
+  const jsBuiltins = ["parseInt", "parseFloat", "String", "Number", "Boolean", "Array", "Object", "JSON", "Math", "Date", "encodeURIComponent", "decodeURIComponent", "encodeURI", "decodeURI", "true", "false", "null", "undefined", "NaN", "Infinity", "isNaN", "isFinite", "window", "document", "console"];
+  let exprWithoutStrings = expr.replace(/'[^']*'/g, "").replace(/"[^"]*"/g, ""), tplResult = "", inTpl = !1, tplDepth = 0;
+  for (let ti = 0;ti < exprWithoutStrings.length; ti++) {
+    const ch = exprWithoutStrings[ti];
+    if (!inTpl && ch === "`") {
+      inTpl = !0;
+      tplDepth = 0;
+      continue;
+    }
+    if (inTpl) {
+      if (ch === "`" && tplDepth === 0) {
+        inTpl = !1;
+        continue;
+      }
+      if (ch === "$" && exprWithoutStrings[ti + 1] === "{") {
+        tplDepth++;
+        ti++;
+        tplResult += " ";
+        continue;
+      }
+      if (ch === "}" && tplDepth > 0) {
+        tplDepth--;
+        continue;
+      }
+      if (tplDepth > 0) {
+        tplResult += ch;
+        continue;
+      }
+      continue;
+    }
+    tplResult += ch;
+  }
+  exprWithoutStrings = tplResult;
+  const identifierRegex = /(?<![a-zA-Z0-9_$])([a-zA-Z_$][a-zA-Z0-9_$]*)/g;
+  let identifierMatch;
+  while ((identifierMatch = identifierRegex.exec(exprWithoutStrings)) !== null) {
+    const identifier = identifierMatch[1];
+    if (!exprWithoutStrings.substring(0, identifierMatch.index).trimEnd().endsWith(".")) {
+      if (!jsBuiltins.includes(identifier) && !(identifier in context))
+        return !1;
+    }
+  }
+  return !0;
+}
+function expressionReadsServerBinding(expr, context) {
+  const declared = context.__stx_serverDeclared;
+  if (!declared || declared.size === 0)
+    return !1;
+  const searchable = stripCommentsAndLiterals(expr);
+  for (const name of declared)
+    if (new RegExp(`(?<![.#\\w$])${name}(?![\\w$])`).test(searchable))
+      return !0;
+  return !1;
+}
+export function interpolateScriptExpressions(scriptBody, context) {
+  let output = scriptBody;
+  output = output.replace(/\{!!([\s\S]*?)!!\}/g, (match, expr) => {
+    try {
+      const value = evaluateExpression(expr, context);
+      if (value === void 0)
+        return match;
+      return value === null ? "" : String(value);
+    } catch {
+      return match;
+    }
+  });
+  output = output.replace(/\{\{([\s\S]*?)\}\}/g, (match, expr) => {
+    const trimmed = expr.trim();
+    if (/^__[A-Z_]+__$/.test(trimmed))
+      return match;
+    try {
+      const value = evaluateExpression(expr, context);
+      if (value === void 0)
+        return match;
+      return JSON.stringify(value).replace(/</g, "\\u003c");
+    } catch {
+      return match;
+    }
+  });
+  return output;
+}
+export function interpolateScriptAttributes(attrs, context) {
+  if (!attrs.includes("{"))
+    return attrs;
+  let output = attrs;
+  output = output.replace(/\{!!([\s\S]*?)!!\}/g, (match, expr) => {
+    try {
+      const value = evaluateExpression(expr, context);
+      if (value === void 0)
+        return match;
+      return value === null ? "" : String(value);
+    } catch {
+      return match;
+    }
+  });
+  output = output.replace(/\{\{([\s\S]*?)\}\}/g, (match, expr) => {
+    const trimmed = expr.trim();
+    if (/^__[A-Z_]+__$/.test(trimmed))
+      return match;
+    try {
+      const value = evaluateExpression(expr, context);
+      if (value === void 0)
+        return match;
+      if (value === null)
+        return "";
+      return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+    } catch {
+      return match;
+    }
+  });
+  return output;
+}
+export function interpolateScriptsInTemplate(template, context, options = {}) {
+  const { output, scripts } = stashScriptElements(template), interpolatedScripts = scripts.map((full) => {
+    const match = full.match(/^<script\b([^>]*)>([\s\S]*?)<\/script\s*>$/i), opening = full.match(/^<script\b[^>]*>/i), closingStart = full.search(/<\/script\s*>$/i);
+    if (!match || !opening || closingStart === -1)
+      return full;
+    const attrs = match[1], body = match[2];
+    if (/\bdata-raw\b/.test(attrs))
+      return full;
+    if (options.skipServer && /\bserver\b/.test(attrs))
+      return full;
+    const openTag = `<script${interpolateScriptAttributes(attrs, context)}>`;
+    if (/\bsrc\s*=/.test(attrs) || /\btype\s*=\s*["']application\/json["']/.test(attrs))
+      return openTag + body + full.slice(closingStart);
+    return openTag + interpolateScriptExpressions(body, context) + full.slice(closingStart);
+  });
+  return restoreStashedScripts(output, interpolatedScripts);
+}
+export function processExpressions(template, context, filePath) {
+  let output = template;
+  const styleMatcher = (html, i) => {
+    const end = matchStyleElement(html, i);
+    if (end === -1)
+      return -1;
+    return /\{\{[\s\S]*?\}\}|\{!![\s\S]*?!!\}/.test(html.slice(i, end)) ? -1 : end;
+  }, maskInto = (src, matcher, store, fmt) => {
+    const base = store.length, { output: out, tokens } = maskAtElementPosition(src, matcher, (_t, idx) => fmt(base + idx));
+    store.push(...tokens);
+    return out;
+  }, styleBlocks = [];
+  output = maskInto(output, styleMatcher, styleBlocks, (n) => `<!--__STX_STYLE_${n}__-->`);
+  const scriptBlocks = [];
+  output = maskInto(output, matchScriptElement, scriptBlocks, (n) => `<!--__STX_SCRIPT_EXPR_${n}__-->`);
+  const hasSignals = context?.__stx_signals_gate === !0 || usesSignalsInScript(template), clientSignalNames = new Set(Array.isArray(context?.__stx_client_signal_names) ? context.__stx_client_signal_names : []), preservedClientExpressions = new Set(Array.isArray(context?.__stx_preserved_client_expressions) ? context.__stx_preserved_client_expressions : []);
+  output = output.replace(/\{\{\{([\s\S]*?)\}\}\}/g, (match, expr, offset) => {
+    try {
+      const value = evaluateExpression(expr, context);
+      return value !== void 0 && value !== null ? String(value) : "";
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      return createDetailedErrorMessage("Expression", `Error evaluating: {{{ ${expr.trim()}}}}: ${msg}`, filePath, template, offset, match);
+    }
+  });
+  output = output.replace(/\{!!([\s\S]*?)!!\}/g, (match, expr, offset) => {
+    try {
+      const value = evaluateExpression(expr, context);
+      if (value === void 0 && context.__stx_buildMode === "compile")
+        return createPlaceholder("raw", expr.trim());
+      return value !== void 0 && value !== null ? String(value) : "";
+    } catch (error) {
+      if (context.__stx_buildMode === "compile")
+        return createPlaceholder("raw", expr.trim());
+      const msg = error instanceof Error ? error.message : String(error);
+      return createDetailedErrorMessage("Expression", `Error evaluating: {!! ${expr.trim()} !!}: ${msg}`, filePath, template, offset, match);
+    }
+  });
+  output = maskInto(output, matchScriptElement, scriptBlocks, (n) => `<!--__STX_SCRIPT_EXPR_${n}__-->`);
+  output = maskInto(output, styleMatcher, styleBlocks, (n) => `<!--__STX_STYLE_${n}__-->`);
+  output = output.replace(/\{\{([\s\S]*?)\}\}/g, (match, expr, offset) => {
+    const trimmedExpr = expr.trim();
+    if (preservedClientExpressions.has(trimmedExpr))
+      return match;
+    const jsBuiltins = ["parseInt", "parseFloat", "String", "Number", "Boolean", "Array", "Object", "JSON", "Math", "Date", "encodeURIComponent", "decodeURIComponent", "encodeURI", "decodeURI", "true", "false", "null", "undefined"], identifierPattern = /^([a-zA-Z_$][a-zA-Z0-9_$]*)/, firstVarName = trimmedExpr.match(identifierPattern)?.[1], firstVarInContext = firstVarName && ((firstVarName in context) || jsBuiltins.includes(firstVarName)), firstVarIsClientSignal = Boolean(firstVarName && clientSignalNames.has(firstVarName)), directFunctionCall = /^([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/, directFuncMatch = trimmedExpr.match(directFunctionCall), isLikelySignal = directFuncMatch && !jsBuiltins.includes(directFuncMatch[1]) && !(directFuncMatch[1] in context);
+    if (/^__[A-Z_]+__$/.test(trimmedExpr))
+      return "";
+    try {
+      const value = evaluateExpression(expr, context);
+      if (firstVarIsClientSignal)
+        return match;
+      if (hasSignals && !expressionUsesOnlyContextVars(trimmedExpr, context))
+        return match;
+      if (context.__stx_buildMode === "compile" && !hasSignals && (value === void 0 || expressionReadsServerBinding(trimmedExpr, context)))
+        return createPlaceholder("expr", trimmedExpr);
+      return value !== void 0 && value !== null ? escapeHtmlValue(String(value)) : "";
+    } catch (error) {
+      if (firstVarIsClientSignal)
+        return match;
+      if (hasSignals && !expressionUsesOnlyContextVars(trimmedExpr, context))
+        return match;
+      if (isLikelySignal)
+        return match;
+      const msg = error instanceof Error ? error.message : String(error);
+      return createDetailedErrorMessage("Expression", `Error evaluating: {{ ${trimmedExpr} }}: ${msg}`, filePath, template, offset, match);
+    }
+  });
+  if (scriptBlocks.length > 0)
+    output = output.replace(/<!--__STX_SCRIPT_EXPR_(\d+)__-->/g, (match, i) => scriptBlocks[Number(i)] ?? match);
+  if (styleBlocks.length > 0)
+    output = output.replace(/<!--__STX_STYLE_(\d+)__-->/g, (match, i) => styleBlocks[Number(i)] ?? match);
+  return output;
+}
+export function applyFilters(value, filterExpression, context) {
+  if (!filterExpression.trim())
+    return value;
+  let result = value, 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 = customFilters[filterName] || defaultFilters[filterName];
+    if (!filterFn)
+      throw Error(`Filter not found: ${filterName}. Available filters: ${Object.keys(getAllFilters()).join(", ")}`);
+    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, 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("}"))
+              params = [evaluateExpression(`(${paramsString})`, context, !0)];
+            else {
+              const paramParts = [];
+              let current = "", inStr = null, pDepth = 0, bDepth = 0, brDepth = 0, esc = !1;
+              for (let ci = 0;ci < paramsString.length; ci++) {
+                const ch = paramsString[ci];
+                if (esc) {
+                  current += ch;
+                  esc = !1;
+                  continue;
+                }
+                if (ch === "\\") {
+                  current += ch;
+                  esc = !0;
+                  continue;
+                }
+                if (inStr) {
+                  current += ch;
+                  if (ch === inStr)
+                    inStr = null;
+                  continue;
+                }
+                if (ch === '"' || ch === "'" || ch === "`") {
+                  inStr = ch;
+                  current += ch;
+                  continue;
+                }
+                if (ch === "(")
+                  pDepth++;
+                else if (ch === ")")
+                  pDepth--;
+                else if (ch === "[")
+                  bDepth++;
+                else if (ch === "]")
+                  bDepth--;
+                else if (ch === "{")
+                  brDepth++;
+                else if (ch === "}")
+                  brDepth--;
+                if (ch === "," && pDepth === 0 && bDepth === 0 && brDepth === 0) {
+                  paramParts.push(current);
+                  current = "";
+                  continue;
+                }
+                current += ch;
+              }
+              if (current)
+                paramParts.push(current);
+              params = paramParts.map((p) => {
+                const trimmed = p.trim();
+                return evaluateExpression(trimmed, context, !0);
+              });
+            }
+          } catch {
+            params = [paramsString];
+          }
+        remainingExpression = remainingExpression.substring(closeIndex).trim();
+      }
+    }
+    try {
+      result = filterFn(result, context, ...params);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      throw Error(`Error applying filter '${filterName}': ${msg}`);
+    }
+    if (remainingExpression.startsWith("|"))
+      remainingExpression = remainingExpression.substring(1).trim();
+    else
+      break;
+  }
+  return result;
+}
+function findFilterPipeIndex(expr) {
+  let inString = !1, stringChar = "", parenDepth = 0, bracketDepth = 0, braceDepth = 0, escaped = !1;
+  for (let i = 0;i < expr.length; i++) {
+    const char = expr[i], nextChar = expr[i + 1];
+    if (inString && escaped) {
+      escaped = !1;
+      continue;
+    }
+    if (inString && char === "\\") {
+      escaped = !0;
+      continue;
+    }
+    escaped = !1;
+    if ((char === '"' || char === "'" || char === "`") && !escaped) {
+      if (!inString) {
+        inString = !0;
+        stringChar = char;
+      } else if (char === stringChar) {
+        inString = !1;
+        stringChar = "";
+      }
+      continue;
+    }
+    if (inString && stringChar === "`" && char === "$" && nextChar === "{") {
+      let tplDepth = 1;
+      i += 2;
+      while (i < expr.length && tplDepth > 0) {
+        if (expr[i] === "{")
+          tplDepth++;
+        else if (expr[i] === "}")
+          tplDepth--;
+        if (tplDepth > 0)
+          i++;
+      }
+      continue;
+    }
+    if (inString)
+      continue;
+    if (char === "(")
+      parenDepth++;
+    else if (char === ")")
+      parenDepth--;
+    else if (char === "[")
+      bracketDepth++;
+    else if (char === "]")
+      bracketDepth--;
+    else if (char === "{")
+      braceDepth++;
+    else if (char === "}")
+      braceDepth--;
+    if (char === "|" && parenDepth === 0 && bracketDepth === 0 && braceDepth === 0) {
+      if (nextChar === "|") {
+        i++;
+        continue;
+      }
+      if (nextChar === "=") {
+        i++;
+        continue;
+      }
+      return i;
+    }
+  }
+  return -1;
+}
+export function evaluateExpression(expression, context, silent = !1) {
+  try {
+    const trimmedExpr = expression.trim(), filterPipeIndex = findFilterPipeIndex(trimmedExpr);
+    if (filterPipeIndex > 0) {
+      const baseExpr = trimmedExpr.substring(0, filterPipeIndex).trim(), filterExpr = trimmedExpr.substring(filterPipeIndex + 1).trim(), baseValue = evaluateExpression(baseExpr, context, !0);
+      return applyFilters(baseValue, filterExpr, context);
+    }
+    if (!isExpressionSafe(trimmedExpr)) {
+      if (!silent)
+        console.warn(`Potentially unsafe expression detected, using safe evaluator: ${trimmedExpr}`);
+      return safeEvaluate(trimmedExpr, context);
+    }
+    try {
+      const keys = Object.keys(context), values = Object.values(context);
+      return createSafeFunction(trimmedExpr, keys)(...values);
+    } catch {
+      return safeEvaluate(trimmedExpr, context);
+    }
+  } catch (error) {
+    if (error instanceof ReferenceError) {
+      const m = /(\b\w+)\s+is not defined/.exec(error.message);
+      if (m) {
+        const missing = m[1], suggestion = closestKey(missing, Object.keys(context));
+        if (suggestion && suggestion !== missing)
+          error.message = `${error.message} \u2014 did you mean '${suggestion}'?`;
+      }
+    }
+    if (!silent)
+      console.error(`Error evaluating expression: ${expression}`, error);
+    throw error;
+  }
+}
+function closestKey(name, keys) {
+  let best = null;
+  for (const k of keys) {
+    if (k === name)
+      continue;
+    const d = levenshtein(name, k);
+    if (best === null || d < best.dist)
+      best = { key: k, dist: d };
+  }
+  if (!best)
+    return null;
+  const longer = Math.max(name.length, best.key.length);
+  if (best.dist <= 2 || best.dist / longer <= 0.35)
+    return best.key;
+  return null;
+}
+function levenshtein(a, b) {
+  if (a === b)
+    return 0;
+  if (a.length === 0)
+    return b.length;
+  if (b.length === 0)
+    return a.length;
+  const [shorter, longer] = a.length < b.length ? [a, b] : [b, a], prev = Array(shorter.length + 1), curr = Array(shorter.length + 1);
+  for (let i = 0;i <= shorter.length; i++)
+    prev[i] = i;
+  for (let j = 1;j <= longer.length; j++) {
+    curr[0] = j;
+    for (let i = 1;i <= shorter.length; i++) {
+      const cost = shorter[i - 1] === longer[j - 1] ? 0 : 1;
+      curr[i] = Math.min(curr[i - 1] + 1, prev[i] + 1, prev[i - 1] + cost);
+    }
+    for (let i = 0;i <= shorter.length; i++)
+      prev[i] = curr[i];
+  }
+  return prev[shorter.length];
+}
+export function unescapeHtml(html) {
+  if (!html)
+    return "";
+  return html.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#039;/g, "'").replace(/&#39;/g, "'").replace(/&amp;/g, "&");
+}