@mejazbese21/obsidian-clipper-cli 1.6.3

package/dist/api.mjs

@@ -0,0 +1,5018 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/api.ts
+import DefuddleClass from "defuddle";
+import { createMarkdownContent as createMarkdownContent2 } from "defuddle/full";
+
+// src/utils/tokenizer.ts
+var KEYWORDS = {
+  "if": "keyword_if",
+  "elseif": "keyword_elseif",
+  "else": "keyword_else",
+  "endif": "keyword_endif",
+  "for": "keyword_for",
+  "in": "keyword_in",
+  "endfor": "keyword_endfor",
+  "set": "keyword_set",
+  "and": "op_and",
+  "or": "op_or",
+  "not": "op_not",
+  "contains": "op_contains",
+  "true": "boolean",
+  "false": "boolean",
+  "null": "null"
+};
+function tokenize(input) {
+  const state = {
+    input,
+    pos: 0,
+    line: 1,
+    column: 1,
+    mode: "text",
+    tokens: [],
+    errors: []
+  };
+  while (state.pos < state.input.length) {
+    switch (state.mode) {
+      case "text":
+        tokenizeText(state);
+        break;
+      case "variable":
+        tokenizeVariable(state);
+        break;
+      case "tag":
+        tokenizeTag(state);
+        break;
+    }
+  }
+  state.tokens.push({
+    type: "eof",
+    value: "",
+    line: state.line,
+    column: state.column
+  });
+  return {
+    tokens: state.tokens,
+    errors: state.errors
+  };
+}
+function tokenizeText(state) {
+  const startPos = state.pos;
+  const startLine = state.line;
+  const startColumn = state.column;
+  while (state.pos < state.input.length) {
+    if (lookAhead(state, "{{")) {
+      if (state.pos > startPos) {
+        state.tokens.push({
+          type: "text",
+          value: state.input.slice(startPos, state.pos),
+          line: startLine,
+          column: startColumn
+        });
+      }
+      advance(state, 2);
+      state.tokens.push({
+        type: "variable_start",
+        value: "{{",
+        line: state.line,
+        column: state.column - 2,
+        trimLeft: false
+        // Variables preserve whitespace by default
+      });
+      state.mode = "variable";
+      return;
+    }
+    if (lookAhead(state, "{%")) {
+      if (state.pos > startPos) {
+        state.tokens.push({
+          type: "text",
+          value: state.input.slice(startPos, state.pos),
+          line: startLine,
+          column: startColumn
+        });
+      }
+      advance(state, 2);
+      state.tokens.push({
+        type: "tag_start",
+        value: "{%",
+        line: state.line,
+        column: state.column - 2,
+        trimLeft: false
+        // Preserve whitespace before tags
+      });
+      state.mode = "tag";
+      return;
+    }
+    advanceChar(state);
+  }
+  if (state.pos > startPos) {
+    state.tokens.push({
+      type: "text",
+      value: state.input.slice(startPos, state.pos),
+      line: startLine,
+      column: startColumn
+    });
+  }
+}
+function tokenizeVariable(state) {
+  skipWhitespace(state);
+  if (lookAhead(state, "}}")) {
+    state.tokens.push({
+      type: "variable_end",
+      value: "}}",
+      line: state.line,
+      column: state.column,
+      trimRight: false
+      // Variables preserve whitespace by default
+    });
+    advance(state, 2);
+    state.mode = "text";
+    return;
+  }
+  const nextChar = state.input[state.pos + 1];
+  if (state.input[state.pos] === "}" && nextChar !== "}") {
+    const validAfterBrace = ["|", ",", ")", "]", " ", "	", "\n", "\r"];
+    if (!validAfterBrace.includes(nextChar)) {
+      state.errors.push({
+        message: `Malformed variable: expected '}}' but found '}'. Did you forget a '}'?`,
+        line: state.line,
+        column: state.column
+      });
+      state.tokens.push({
+        type: "variable_end",
+        value: "}",
+        line: state.line,
+        column: state.column,
+        trimRight: false
+      });
+      advanceChar(state);
+      state.mode = "text";
+      return;
+    }
+  }
+  if (lookAhead(state, "{%") || lookAhead(state, "{{")) {
+    const varStartIndex = [...state.tokens].reverse().findIndex((t) => t.type === "variable_start");
+    const actualIndex = varStartIndex >= 0 ? state.tokens.length - 1 - varStartIndex : -1;
+    const varStartToken = actualIndex >= 0 ? state.tokens[actualIndex] : null;
+    const startLine = varStartToken?.line || state.line;
+    state.errors.push({
+      message: `Missing closing '}}' for variable`,
+      line: startLine,
+      column: varStartToken?.column || state.column
+    });
+    if (actualIndex >= 0) {
+      state.tokens.splice(actualIndex);
+    }
+    state.mode = "text";
+    return;
+  }
+  tokenizeExpression(state, "variable");
+}
+function tokenizeTag(state) {
+  skipWhitespace(state);
+  if (lookAhead(state, "%}")) {
+    state.tokens.push({
+      type: "tag_end",
+      value: "%}",
+      line: state.line,
+      column: state.column,
+      trimRight: true
+      // Tags always trim whitespace
+    });
+    advance(state, 2);
+    state.mode = "text";
+    return;
+  }
+  if (lookAhead(state, "-%}")) {
+    state.tokens.push({
+      type: "tag_end",
+      value: "-%}",
+      line: state.line,
+      column: state.column,
+      trimRight: true
+    });
+    advance(state, 3);
+    state.mode = "text";
+    return;
+  }
+  if (state.input[state.pos] === "}" && state.pos > 0 && state.input[state.pos - 1] !== "%") {
+    state.errors.push({
+      message: `Malformed tag: expected '%}' but found '}'. Did you forget the '%'?`,
+      line: state.line,
+      column: state.column
+    });
+    state.tokens.push({
+      type: "tag_end",
+      value: "}",
+      line: state.line,
+      column: state.column,
+      trimRight: true
+    });
+    advanceChar(state);
+    state.mode = "text";
+    return;
+  }
+  if (lookAhead(state, "{%") || lookAhead(state, "{{")) {
+    const tagStartIndex = [...state.tokens].reverse().findIndex((t) => t.type === "tag_start");
+    const actualIndex = tagStartIndex >= 0 ? state.tokens.length - 1 - tagStartIndex : -1;
+    const tagStartToken = actualIndex >= 0 ? state.tokens[actualIndex] : null;
+    const startLine = tagStartToken?.line || state.line;
+    state.errors.push({
+      message: `Missing closing '%}' for tag`,
+      line: startLine,
+      column: tagStartToken?.column || state.column
+    });
+    if (actualIndex >= 0) {
+      state.tokens.splice(actualIndex);
+    }
+    state.mode = "text";
+    return;
+  }
+  tokenizeExpression(state, "tag");
+}
+function tokenizeExpression(state, mode) {
+  skipWhitespace(state);
+  if (state.pos >= state.input.length) {
+    state.errors.push({
+      message: mode === "variable" ? `Unclosed variable - missing '}}'` : `Unclosed tag - missing '%}'`,
+      line: state.line,
+      column: state.column
+    });
+    return;
+  }
+  const char = state.input[state.pos];
+  const startLine = state.line;
+  const startColumn = state.column;
+  if (char === '"' || char === "'") {
+    tokenizeString(state);
+    return;
+  }
+  if (isDigit(char) || char === "-" && isDigit(state.input[state.pos + 1])) {
+    tokenizeNumber(state);
+    return;
+  }
+  if (lookAhead(state, "==")) {
+    state.tokens.push({ type: "op_eq", value: "==", line: startLine, column: startColumn });
+    advance(state, 2);
+    return;
+  }
+  if (lookAhead(state, "!=")) {
+    state.tokens.push({ type: "op_neq", value: "!=", line: startLine, column: startColumn });
+    advance(state, 2);
+    return;
+  }
+  if (lookAhead(state, ">=")) {
+    state.tokens.push({ type: "op_gte", value: ">=", line: startLine, column: startColumn });
+    advance(state, 2);
+    return;
+  }
+  if (lookAhead(state, "<=")) {
+    state.tokens.push({ type: "op_lte", value: "<=", line: startLine, column: startColumn });
+    advance(state, 2);
+    return;
+  }
+  if (lookAhead(state, "&&")) {
+    state.tokens.push({ type: "op_and", value: "&&", line: startLine, column: startColumn });
+    advance(state, 2);
+    return;
+  }
+  if (lookAhead(state, "||")) {
+    state.tokens.push({ type: "op_or", value: "||", line: startLine, column: startColumn });
+    advance(state, 2);
+    return;
+  }
+  if (lookAhead(state, "??")) {
+    state.tokens.push({ type: "op_nullish", value: "??", line: startLine, column: startColumn });
+    advance(state, 2);
+    return;
+  }
+  if (lookAhead(state, "=>")) {
+    state.tokens.push({ type: "arrow", value: "=>", line: startLine, column: startColumn });
+    advance(state, 2);
+    return;
+  }
+  switch (char) {
+    case ">":
+      state.tokens.push({ type: "op_gt", value: ">", line: startLine, column: startColumn });
+      advanceChar(state);
+      return;
+    case "<":
+      state.tokens.push({ type: "op_lt", value: "<", line: startLine, column: startColumn });
+      advanceChar(state);
+      return;
+    case "!":
+      state.tokens.push({ type: "op_not", value: "!", line: startLine, column: startColumn });
+      advanceChar(state);
+      return;
+    case "=":
+      state.tokens.push({ type: "op_assign", value: "=", line: startLine, column: startColumn });
+      advanceChar(state);
+      return;
+    case "|":
+      state.tokens.push({ type: "pipe", value: "|", line: startLine, column: startColumn });
+      advanceChar(state);
+      return;
+    case "(":
+      state.tokens.push({ type: "lparen", value: "(", line: startLine, column: startColumn });
+      advanceChar(state);
+      return;
+    case ")":
+      state.tokens.push({ type: "rparen", value: ")", line: startLine, column: startColumn });
+      advanceChar(state);
+      return;
+    case "[":
+      state.tokens.push({ type: "lbracket", value: "[", line: startLine, column: startColumn });
+      advanceChar(state);
+      return;
+    case "]":
+      state.tokens.push({ type: "rbracket", value: "]", line: startLine, column: startColumn });
+      advanceChar(state);
+      return;
+    case ":":
+      state.tokens.push({ type: "colon", value: ":", line: startLine, column: startColumn });
+      advanceChar(state);
+      return;
+    case ",":
+      state.tokens.push({ type: "comma", value: ",", line: startLine, column: startColumn });
+      advanceChar(state);
+      return;
+    case ".":
+      state.tokens.push({ type: "dot", value: ".", line: startLine, column: startColumn });
+      advanceChar(state);
+      return;
+    case "*":
+      state.tokens.push({ type: "star", value: "*", line: startLine, column: startColumn });
+      advanceChar(state);
+      return;
+    case "/":
+      state.tokens.push({ type: "slash", value: "/", line: startLine, column: startColumn });
+      advanceChar(state);
+      return;
+    case "{":
+      state.tokens.push({ type: "lbrace", value: "{", line: startLine, column: startColumn });
+      advanceChar(state);
+      return;
+    case "}":
+      state.tokens.push({ type: "rbrace", value: "}", line: startLine, column: startColumn });
+      advanceChar(state);
+      return;
+    case "$":
+      state.tokens.push({ type: "dollar", value: "$", line: startLine, column: startColumn });
+      advanceChar(state);
+      return;
+  }
+  if (isIdentifierStart(char)) {
+    tokenizeIdentifier(state);
+    return;
+  }
+  if (char === "\\") {
+    tokenizeEscapedArgument(state);
+    return;
+  }
+  state.errors.push({
+    message: `Unexpected character '${char}' in template`,
+    line: state.line,
+    column: state.column
+  });
+  advanceChar(state);
+}
+function tokenizeString(state) {
+  const quote = state.input[state.pos];
+  const startLine = state.line;
+  const startColumn = state.column;
+  let value = "";
+  advanceChar(state);
+  while (state.pos < state.input.length) {
+    const char = state.input[state.pos];
+    const nextChar = state.input[state.pos + 1] || "";
+    if (char === quote) {
+      advanceChar(state);
+      state.tokens.push({
+        type: "string",
+        value,
+        line: startLine,
+        column: startColumn
+      });
+      return;
+    }
+    if (char === "}" && nextChar === "}" || char === "%" && nextChar === "}") {
+      state.errors.push({
+        message: `Unclosed string - missing ${quote} before ${char}${nextChar}`,
+        line: startLine,
+        column: startColumn
+      });
+      state.tokens.push({
+        type: "string",
+        value,
+        line: startLine,
+        column: startColumn
+      });
+      return;
+    }
+    if (char === "\\" && state.pos + 1 < state.input.length) {
+      advanceChar(state);
+      const escaped = state.input[state.pos];
+      switch (escaped) {
+        case "n":
+          value += "\n";
+          break;
+        case "t":
+          value += "	";
+          break;
+        case "r":
+          value += "\r";
+          break;
+        case "\\":
+          value += "\\";
+          break;
+        case '"':
+          value += '"';
+          break;
+        case "'":
+          value += "'";
+          break;
+        default:
+          value += escaped;
+      }
+      advanceChar(state);
+      continue;
+    }
+    value += char;
+    advanceChar(state);
+  }
+  state.errors.push({
+    message: `Unclosed string - missing closing ${quote}`,
+    line: startLine,
+    column: startColumn
+  });
+  state.tokens.push({
+    type: "string",
+    value,
+    line: startLine,
+    column: startColumn
+  });
+}
+function tokenizeEscapedArgument(state) {
+  const startLine = state.line;
+  const startColumn = state.column;
+  let value = "";
+  while (state.pos < state.input.length) {
+    const char = state.input[state.pos];
+    const nextChar = state.input[state.pos + 1] || "";
+    if (char === "|" || char === "%" || char === "}" || char === ")") {
+      break;
+    }
+    if (char === "+" && (nextChar === "%" || nextChar === "}")) {
+      break;
+    }
+    if (char === "\\" && state.pos + 1 < state.input.length) {
+      const escaped = state.input[state.pos + 1];
+      switch (escaped) {
+        case '"':
+          value += '"';
+          break;
+        case "'":
+          value += "'";
+          break;
+        case "\\":
+          value += "\\";
+          break;
+        case "n":
+          value += "\n";
+          break;
+        case "t":
+          value += "	";
+          break;
+        case "r":
+          value += "\r";
+          break;
+        case ",":
+          value += ",";
+          break;
+        case "|":
+          value += "|";
+          break;
+        default:
+          value += escaped;
+      }
+      advanceChar(state);
+      advanceChar(state);
+      continue;
+    }
+    value += char;
+    advanceChar(state);
+  }
+  state.tokens.push({
+    type: "string",
+    value,
+    line: startLine,
+    column: startColumn
+  });
+}
+function tokenizeNumber(state) {
+  const startLine = state.line;
+  const startColumn = state.column;
+  let value = "";
+  if (state.input[state.pos] === "-") {
+    value += "-";
+    advanceChar(state);
+  }
+  while (state.pos < state.input.length && isDigit(state.input[state.pos])) {
+    value += state.input[state.pos];
+    advanceChar(state);
+  }
+  if (state.pos < state.input.length && state.input[state.pos] === ".") {
+    value += ".";
+    advanceChar(state);
+    while (state.pos < state.input.length && isDigit(state.input[state.pos])) {
+      value += state.input[state.pos];
+      advanceChar(state);
+    }
+  }
+  state.tokens.push({
+    type: "number",
+    value,
+    line: startLine,
+    column: startColumn
+  });
+}
+function tokenizeIdentifier(state) {
+  const startLine = state.line;
+  const startColumn = state.column;
+  let value = "";
+  while (state.pos < state.input.length && isIdentifierChar(state.input[state.pos])) {
+    value += state.input[state.pos];
+    advanceChar(state);
+  }
+  if ((value === "selector" || value === "selectorHtml") && state.pos < state.input.length && state.input[state.pos] === ":") {
+    value += ":";
+    advanceChar(state);
+    value = tokenizeCssSelector(state, value);
+  }
+  const lowerValue = value.toLowerCase();
+  const keywordType = KEYWORDS[lowerValue];
+  if (keywordType) {
+    state.tokens.push({
+      type: keywordType,
+      value,
+      line: startLine,
+      column: startColumn
+    });
+  } else {
+    state.tokens.push({
+      type: "identifier",
+      value,
+      line: startLine,
+      column: startColumn
+    });
+  }
+}
+function tokenizeCssSelector(state, value) {
+  let bracketDepth = 0;
+  let parenDepth = 0;
+  let inString = null;
+  while (state.pos < state.input.length) {
+    const char = state.input[state.pos];
+    const nextChar = state.input[state.pos + 1] || "";
+    if (!inString && bracketDepth === 0 && parenDepth === 0) {
+      if (char === "|") {
+        break;
+      }
+      if (char === "%" && nextChar === "}") {
+        break;
+      }
+      if (char === "}" && nextChar === "}") {
+        break;
+      }
+      if (char === "-" && nextChar === "%") {
+        break;
+      }
+      if (char === "-" && nextChar === "}") {
+        break;
+      }
+      if (char === "}" && nextChar !== "}") {
+        break;
+      }
+    }
+    if (char === "}" && nextChar === "}" || char === "%" && nextChar === "}") {
+      if (inString) {
+        state.errors.push({
+          message: `Unclosed string in selector - missing closing ${inString}`,
+          line: state.line,
+          column: state.column
+        });
+        break;
+      }
+      if (bracketDepth > 0) {
+        state.errors.push({
+          message: `Unclosed '[' in selector - missing ']'`,
+          line: state.line,
+          column: state.column
+        });
+        break;
+      }
+      if (parenDepth > 0) {
+        state.errors.push({
+          message: `Unclosed '(' in selector - missing ')'`,
+          line: state.line,
+          column: state.column
+        });
+        break;
+      }
+    }
+    if (!inString && char === "\\" && (nextChar === '"' || nextChar === "'")) {
+      value += char;
+      advanceChar(state);
+      value += state.input[state.pos];
+      advanceChar(state);
+      continue;
+    }
+    if (!inString && (char === '"' || char === "'")) {
+      inString = char;
+      value += char;
+      advanceChar(state);
+      continue;
+    }
+    if (inString && char === inString) {
+      inString = null;
+      value += char;
+      advanceChar(state);
+      continue;
+    }
+    if (inString && char === "\\" && state.pos + 1 < state.input.length) {
+      value += char;
+      advanceChar(state);
+      value += state.input[state.pos];
+      advanceChar(state);
+      continue;
+    }
+    if (!inString) {
+      if (char === "[") {
+        bracketDepth++;
+      } else if (char === "]") {
+        bracketDepth--;
+        if (bracketDepth < 0) {
+          state.errors.push({
+            message: `Extra ']' in selector - no matching '['`,
+            line: state.line,
+            column: state.column
+          });
+          bracketDepth = 0;
+        }
+      } else if (char === "(") {
+        parenDepth++;
+      } else if (char === ")") {
+        parenDepth--;
+        if (parenDepth < 0) {
+          state.errors.push({
+            message: `Extra ')' in selector - no matching '('`,
+            line: state.line,
+            column: state.column
+          });
+          parenDepth = 0;
+        }
+      }
+    }
+    value += char;
+    advanceChar(state);
+  }
+  return value.trimEnd();
+}
+function lookAhead(state, str) {
+  return state.input.slice(state.pos, state.pos + str.length) === str;
+}
+function advance(state, count) {
+  for (let i = 0; i < count; i++) {
+    advanceChar(state);
+  }
+}
+function advanceChar(state) {
+  if (state.pos < state.input.length) {
+    if (state.input[state.pos] === "\n") {
+      state.line++;
+      state.column = 1;
+    } else {
+      state.column++;
+    }
+    state.pos++;
+  }
+}
+function skipWhitespace(state) {
+  while (state.pos < state.input.length && isWhitespace(state.input[state.pos])) {
+    advanceChar(state);
+  }
+}
+function isWhitespace(char) {
+  return char === " " || char === "	" || char === "\n" || char === "\r";
+}
+function isDigit(char) {
+  return char >= "0" && char <= "9";
+}
+function isIdentifierStart(char) {
+  return char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char === "_" || char === "@";
+}
+function isIdentifierChar(char) {
+  return isIdentifierStart(char) || isDigit(char) || char === "-" || // For kebab-case
+  char === ".";
+}
+
+// src/utils/cli-stubs.ts
+var cli_stubs_exports = {};
+__export(cli_stubs_exports, {
+  default: () => cli_stubs_default,
+  generalSettings: () => generalSettings,
+  getLocalStorage: () => getLocalStorage,
+  incrementStat: () => incrementStat,
+  loadSettings: () => loadSettings,
+  saveSettings: () => saveSettings,
+  setLocalStorage: () => setLocalStorage
+});
+var cli_stubs_default = {};
+var generalSettings = {
+  vaults: [],
+  betaFeatures: false,
+  legacyMode: false,
+  silentOpen: false,
+  openBehavior: "popup",
+  highlighterEnabled: false,
+  alwaysShowHighlights: false,
+  highlightBehavior: "no-highlights",
+  showMoreActionsButton: false,
+  interpreterModel: "",
+  models: [],
+  providers: [],
+  interpreterEnabled: false,
+  interpreterAutoRun: false,
+  defaultPromptContext: "",
+  propertyTypes: [],
+  readerSettings: {
+    fontSize: 16,
+    lineHeight: 1.5,
+    maxWidth: 700,
+    lightTheme: "default",
+    darkTheme: "same",
+    appearance: "auto",
+    fonts: [],
+    defaultFont: "",
+    blendImages: true,
+    colorLinks: false,
+    followLinks: true,
+    pinPlayer: true,
+    autoScroll: true,
+    highlightActiveLine: true,
+    customCss: ""
+  },
+  stats: {
+    addToObsidian: 0,
+    saveFile: 0,
+    copyToClipboard: 0,
+    share: 0
+  },
+  history: [],
+  ratings: [],
+  saveBehavior: "addToObsidian"
+};
+var loadSettings = async () => {
+};
+var saveSettings = async () => {
+};
+var incrementStat = async () => {
+};
+var getLocalStorage = async () => ({});
+var setLocalStorage = async () => {
+};
+
+// src/utils/browser-polyfill.ts
+var browser_polyfill_default = cli_stubs_exports;
+
+// src/utils/debug.ts
+if (false) {
+  browser_polyfill_default.storage.local.get("debugMode").then((result) => {
+    debugMode = result.debugMode ?? false;
+    console.log(`Debug mode initialized to: ${debugMode ? "ON" : "OFF"}`);
+  }).catch((error) => {
+    console.error("Error initializing debug mode:", error);
+  });
+}
+var debugLog = (filterName, ...args) => {
+  if (false) {
+    console.log(`[${filterName}]`, ...args);
+  }
+};
+if (false) {
+  globalThis.toggleDebug = toggleDebug;
+}
+
+// src/utils/parser-utils.ts
+function createParserState(initialCurrent = "") {
+  return {
+    current: initialCurrent,
+    inQuote: false,
+    quoteType: "",
+    inRegex: false,
+    curlyDepth: 0,
+    parenDepth: 0,
+    escapeNext: false
+  };
+}
+function processCharacter(char, state) {
+  if (state.escapeNext) {
+    state.current += char;
+    state.escapeNext = false;
+    return;
+  }
+  if (char === "\\") {
+    state.current += char;
+    if (!state.inRegex) {
+      state.escapeNext = true;
+    }
+    return;
+  }
+  if ((char === '"' || char === "'") && !state.inRegex) {
+    state.inQuote = !state.inQuote;
+    state.quoteType = state.inQuote ? char : "";
+    state.current += char;
+    return;
+  }
+  if (char === "/" && !state.inQuote && !state.inRegex && (state.current.endsWith(":") || state.current.endsWith(","))) {
+    state.inRegex = true;
+    state.current += char;
+    return;
+  }
+  if (char === "/" && state.inRegex && !state.escapeNext) {
+    state.inRegex = false;
+    state.current += char;
+    return;
+  }
+  if (char === "{") {
+    state.curlyDepth++;
+    state.current += char;
+    return;
+  }
+  if (char === "}") {
+    state.curlyDepth--;
+    state.current += char;
+    return;
+  }
+  if (char === "(" && !state.inQuote) {
+    state.parenDepth++;
+    state.current += char;
+    return;
+  }
+  if (char === ")" && !state.inQuote) {
+    state.parenDepth--;
+    state.current += char;
+    return;
+  }
+  state.current += char;
+}
+function parseRegexPattern(pattern) {
+  const match = pattern.match(/^\/(.+)\/([gimsuy]*)$/);
+  if (!match) return null;
+  return {
+    pattern: match[1],
+    flags: match[2]
+  };
+}
+
+// src/utils/filters/blockquote.ts
+var blockquote = (input) => {
+  const processBlockquote = (str, depth = 1) => {
+    const prefix = "> ".repeat(depth);
+    return str.split("\n").map((line) => `${prefix}${line}`).join("\n");
+  };
+  const processArray = (arr, depth = 1) => {
+    return arr.map((item) => {
+      if (Array.isArray(item)) {
+        return processArray(item, depth + 1);
+      }
+      return processBlockquote(String(item), depth);
+    }).join("\n");
+  };
+  try {
+    const parsedInput = JSON.parse(input);
+    if (Array.isArray(parsedInput)) {
+      return processArray(parsedInput);
+    }
+    if (typeof parsedInput === "object" && parsedInput !== null) {
+      return processBlockquote(JSON.stringify(parsedInput, null, 2));
+    }
+    return processBlockquote(String(parsedInput));
+  } catch (error) {
+    if (Array.isArray(input)) {
+      return processArray(input);
+    }
+    return processBlockquote(input);
+  }
+};
+
+// src/utils/filters/calc.ts
+var validateCalcParams = (param) => {
+  if (!param) {
+    return { valid: false, error: 'requires an operation (e.g., calc:"+10", calc:"*2")' };
+  }
+  const operation = param.replace(/^['"](.*)['"]$/, "$1").trim();
+  if (!operation) {
+    return { valid: false, error: "operation cannot be empty" };
+  }
+  const validOperators = ["+", "-", "*", "/", "^", "**"];
+  const operator = operation.slice(0, 2) === "**" ? "**" : operation.charAt(0);
+  if (!validOperators.includes(operator)) {
+    return { valid: false, error: `invalid operator "${operator}". Use +, -, *, /, ^ or **` };
+  }
+  const valueStr = operation.slice(operator === "**" ? 2 : 1);
+  if (!valueStr || isNaN(Number(valueStr))) {
+    return { valid: false, error: 'requires a number after the operator (e.g., "+10")' };
+  }
+  return { valid: true };
+};
+var calc = (str, param) => {
+  if (!param) {
+    return str;
+  }
+  try {
+    const num = Number(str);
+    if (isNaN(num)) {
+      console.error("Input is not a number:", str);
+      return str;
+    }
+    const operation = param.replace(/^['"](.*)['"]$/, "$1").trim();
+    const operator = operation.slice(0, 2) === "**" ? "**" : operation.charAt(0);
+    const value = Number(operation.slice(operator === "**" ? 2 : 1));
+    if (isNaN(value)) {
+      console.error("Invalid calculation value:", operation);
+      return str;
+    }
+    let result;
+    switch (operator) {
+      case "+":
+        result = num + value;
+        break;
+      case "-":
+        result = num - value;
+        break;
+      case "*":
+        result = num * value;
+        break;
+      case "/":
+        result = num / value;
+        break;
+      case "**":
+      case "^":
+        result = Math.pow(num, value);
+        break;
+      default:
+        console.error("Invalid operator:", operator);
+        return str;
+    }
+    return Number(result.toFixed(10)).toString();
+  } catch (error) {
+    console.error("Error in calc filter:", error);
+    return str;
+  }
+};
+
+// src/utils/filters/callout.ts
+var callout = (str, param) => {
+  let type = "info";
+  let title2 = "";
+  let foldState = null;
+  if (param) {
+    param = param.replace(/^\((.*)\)$/, "$1");
+    const params = param.split(/,(?=(?:(?:[^"']*["'][^"']*["'])*[^"']*$))/).map((p) => {
+      return p.trim().replace(/^(['"])([\s\S]*)\1$/, "$2");
+    });
+    if (params.length > 0) type = params[0] || type;
+    if (params.length > 1) title2 = params[1] || title2;
+    if (params.length > 2) {
+      if (params[2].toLowerCase() === "true") foldState = "-";
+      else if (params[2].toLowerCase() === "false") foldState = "+";
+    }
+  }
+  let calloutHeader = `> [!${type}]`;
+  if (foldState) calloutHeader += foldState;
+  if (title2) calloutHeader += ` ${title2}`;
+  return `${calloutHeader}
+${str.split("\n").map((line) => `> ${line}`).join("\n")}`;
+};
+
+// src/utils/filters/camel.ts
+var camel = (str) => str.replace(
+  /(?:^\w|[A-Z]|\b\w)/g,
+  (letter, index) => index === 0 ? letter.toLowerCase() : letter.toUpperCase()
+).replace(/[\s_-]+/g, "");
+
+// src/utils/filters/capitalize.ts
+var capitalize = (input) => {
+  const capitalizeString = (str) => str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+  try {
+    const parseAndCapitalize = (value) => {
+      if (typeof value === "string") {
+        return capitalizeString(value);
+      } else if (Array.isArray(value)) {
+        return value.map(parseAndCapitalize);
+      } else if (typeof value === "object" && value !== null) {
+        const result = {};
+        for (const [key, val] of Object.entries(value)) {
+          result[capitalizeString(key)] = parseAndCapitalize(val);
+        }
+        return result;
+      }
+      return value;
+    };
+    const parsed = JSON.parse(input);
+    const capitalized = parseAndCapitalize(parsed);
+    return JSON.stringify(capitalized);
+  } catch (error) {
+    return capitalizeString(input);
+  }
+};
+
+// src/utils/filters/date.ts
+import dayjs from "dayjs";
+import isoWeek from "dayjs/plugin/isoWeek";
+import weekOfYear from "dayjs/plugin/weekOfYear";
+import customParseFormat from "dayjs/plugin/customParseFormat";
+import advancedFormat from "dayjs/plugin/advancedFormat";
+dayjs.extend(customParseFormat);
+dayjs.extend(isoWeek);
+dayjs.extend(weekOfYear);
+dayjs.extend(advancedFormat);
+var date = (str, param) => {
+  if (str === "") {
+    return str;
+  }
+  const inputDate = str === "now" ? /* @__PURE__ */ new Date() : str;
+  if (!param) {
+    return dayjs(inputDate).format("YYYY-MM-DD");
+  }
+  param = param.replace(/^\((.*)\)$/, "$1");
+  const params = param.split(/,(?=(?:(?:[^"']*["'][^"']*["'])*[^"']*$))/).map((p) => {
+    return p.trim().replace(/^(['"])([\s\S]*)\1$/, "$2");
+  });
+  const [outputFormat, inputFormat] = params;
+  let date2;
+  if (inputFormat) {
+    date2 = dayjs(inputDate, inputFormat, true);
+  } else {
+    date2 = dayjs(inputDate);
+  }
+  if (!date2.isValid()) {
+    console.error("Invalid date for date filter:", str);
+    return str;
+  }
+  return date2.format(outputFormat);
+};
+
+// src/utils/filters/date_modify.ts
+import dayjs2 from "dayjs";
+import isoWeek2 from "dayjs/plugin/isoWeek";
+import weekOfYear2 from "dayjs/plugin/weekOfYear";
+import customParseFormat2 from "dayjs/plugin/customParseFormat";
+import advancedFormat2 from "dayjs/plugin/advancedFormat";
+dayjs2.extend(customParseFormat2);
+dayjs2.extend(isoWeek2);
+dayjs2.extend(weekOfYear2);
+dayjs2.extend(advancedFormat2);
+var validUnits = ["year", "years", "month", "months", "week", "weeks", "day", "days", "hour", "hours", "minute", "minutes", "second", "seconds"];
+var validateDateModifyParams = (param) => {
+  if (!param) {
+    return { valid: false, error: 'requires a modifier (e.g., date_modify:"+1 day", "-2 weeks")' };
+  }
+  let cleanParam = param.replace(/^\((.*)\)$/, "$1");
+  cleanParam = cleanParam.replace(/^(['"])([\s\S]*)\1$/, "$2").trim();
+  const regex = /^([+-])\s*(\d+)\s*(\w+)s?$/;
+  const match = cleanParam.match(regex);
+  if (!match) {
+    return { valid: false, error: 'invalid format. Use "+1 day", "-2 weeks", etc.' };
+  }
+  const [, , , unit] = match;
+  const normalizedUnit = unit.toLowerCase().replace(/s$/, "");
+  if (!validUnits.some((u) => u.replace(/s$/, "") === normalizedUnit)) {
+    return { valid: false, error: `invalid unit "${unit}". Use year, month, week, day, hour, minute, or second` };
+  }
+  return { valid: true };
+};
+var date_modify = (str, param) => {
+  if (!param) {
+    console.error("date_modify filter requires a parameter");
+    return str;
+  }
+  if (str === "") {
+    return str;
+  }
+  let date2 = dayjs2(str);
+  if (!date2.isValid()) {
+    console.error("Invalid date for date_modify filter:", str);
+    return str;
+  }
+  param = param.replace(/^\((.*)\)$/, "$1");
+  param = param.replace(/^(['"])([\s\S]*)\1$/, "$2").trim();
+  const regex = /^([+-])\s*(\d+)\s*(\w+)s?$/;
+  const match = param.match(regex);
+  if (!match) {
+    console.error("Invalid format for date_modify filter:", param);
+    return str;
+  }
+  const [, operation, amount, unit] = match;
+  const numericAmount = parseInt(amount, 10);
+  if (operation === "+") {
+    date2 = date2.add(numericAmount, unit);
+  } else {
+    date2 = date2.subtract(numericAmount, unit);
+  }
+  return date2.format("YYYY-MM-DD");
+};
+
+// src/utils/filters/decode_uri.ts
+var decode_uri = (str) => {
+  try {
+    return decodeURIComponent(str);
+  } catch {
+    return str;
+  }
+};
+
+// src/utils/filters/first.ts
+var first = (str) => {
+  if (str === "") {
+    return str;
+  }
+  try {
+    const array = JSON.parse(str);
+    if (Array.isArray(array) && array.length > 0) {
+      return array[0].toString();
+    }
+  } catch (error) {
+    console.error("Error parsing JSON in first filter:", error);
+  }
+  return str;
+};
+
+// src/utils/filters/footnote.ts
+var footnote = (str) => {
+  if (str === "") {
+    return str;
+  }
+  try {
+    const data = JSON.parse(str);
+    if (Array.isArray(data)) {
+      return data.map((item, index) => `[^${index + 1}]: ${item}`).join("\n\n");
+    } else if (typeof data === "object" && data !== null) {
+      return Object.entries(data).map(([key, value]) => {
+        const footnoteId = key.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+        return `[^${footnoteId}]: ${value}`;
+      }).join("\n\n");
+    }
+  } catch (error) {
+    console.error("Error parsing JSON in footnote filter:", error);
+  }
+  return str;
+};
+
+// src/utils/filters/strip_md.ts
+var strip_md = (str) => {
+  str = str.replace(/!\[([^\]]*)\]\([^\)]+\)/g, "");
+  str = str.replace(/!\[\[([^\]]+)\]\]/g, "");
+  str = str.replace(/\[([^\]]+)\]\([^\)]+\)/g, "$1");
+  str = str.replace(/https?:\/\/\S+/g, "");
+  str = str.replace(/(\*\*|__)(.*?)\1/g, "$2");
+  str = str.replace(/(\*|_)(.*?)\1/g, "$2");
+  str = str.replace(/==(.*?)==/g, "$1");
+  str = str.replace(/^#+\s+/gm, "");
+  str = str.replace(/`([^`]+)`/g, "$1");
+  str = str.replace(/```[\s\S]*?```/g, "");
+  str = str.replace(/~~(.*?)~~/g, "$1");
+  str = str.replace(/^[-*+] (\[[x ]\] )?/gm, "");
+  str = str.replace(/^([-*_]){3,}\s*$/gm, "");
+  str = str.replace(/^>\s+/gm, "");
+  str = str.replace(/\|.*\|/g, "");
+  str = str.replace(/([~^])(\w+)\1/g, "$2");
+  str = str.replace(/:[a-z_]+:/g, "");
+  str = str.replace(/<[^>]+>/g, "");
+  str = str.replace(/\[\s*\]/g, "");
+  str = str.replace(/\[\^[^\]]+\]/g, "");
+  str = str.replace(/^\*\[[^\]]+\]:.+$/gm, "");
+  str = str.replace(/\[\[([^\]|]+)\|?([^\]]*)\]\]/g, (match, p1, p2) => p2 || p1);
+  str = str.replace(/\n{3,}/g, "\n\n");
+  str = str.trim();
+  return str;
+};
+
+// src/utils/filters/fragment_link.ts
+var fragment_link = (str, param) => {
+  if (!param || !str.trim()) {
+    return [str];
+  }
+  const match = param.match(/^(.*?):?((https?:\/\/|file:\/\/).*$)/);
+  const linktext = String(
+    match?.[1]?.trim().replace(/(['"])/g, "") || "link"
+  );
+  const currentUrl = String(match?.[2] || param);
+  const extractTextFragmentParts = (selectedText) => {
+    const text = strip_md(selectedText);
+    const words = text.split(/\s+/).filter(Boolean);
+    if (words.length > 10) {
+      const start = words.slice(0, 5).join(" ");
+      const end = words.slice(-5).join(" ");
+      return { start, end };
+    } else {
+      const start = words.join(" ");
+      return { start };
+    }
+  };
+  const createTextFragmentUrl = (selectedText) => {
+    const { start, end } = extractTextFragmentParts(selectedText);
+    const encodedEnd = end ? "," + encodeURIComponent(end) : "";
+    const textFragment = encodeURIComponent(start) + encodedEnd;
+    return "#:~:text=" + textFragment;
+  };
+  try {
+    const data = JSON.parse(str);
+    if (Array.isArray(data)) {
+      return data.map((item) => {
+        if (typeof item === "object" && item !== null && "text" in item) {
+          return {
+            ...item,
+            text: `${item.text} [${linktext}](${currentUrl}${createTextFragmentUrl(
+              item.text
+            )})`
+          };
+        } else {
+          return `${item} [${linktext}](${currentUrl}${createTextFragmentUrl(
+            String(item)
+          )})`;
+        }
+      });
+    } else if (typeof data === "object" && data !== null) {
+      return Object.entries(data).map(
+        ([key, value]) => `${value} [${linktext}](${currentUrl}${createTextFragmentUrl(
+          String(value)
+        )})`
+      );
+    } else if (typeof data === "string") {
+      return [
+        `${data} [${linktext}](${currentUrl}${createTextFragmentUrl(
+          data
+        )})`
+      ];
+    }
+  } catch (error) {
+    console.error("Fragment filter error:", error);
+  }
+  return [str];
+};
+
+// src/utils/filters/html_to_json.ts
+var html_to_json = (input) => {
+  const parseNode2 = (node) => {
+    if (node.nodeType === Node.TEXT_NODE) {
+      const text = node.textContent?.trim();
+      return text ? { type: "text", content: text } : null;
+    }
+    if (node.nodeType === Node.ELEMENT_NODE) {
+      const element = node;
+      const result = {
+        type: "element",
+        tag: element.tagName.toLowerCase()
+      };
+      const attributes = Array.from(element.attributes).reduce((acc, attr) => {
+        acc[attr.name] = attr.value;
+        return acc;
+      }, {});
+      if (Object.keys(attributes).length > 0) {
+        result.attributes = attributes;
+      }
+      const children = Array.from(element.childNodes).map(parseNode2).filter((child) => child !== null);
+      if (children.length > 0) {
+        result.children = children;
+      }
+      return result;
+    }
+    return null;
+  };
+  try {
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(input, "text/html");
+    const bodyChildren = Array.from(doc.body.childNodes).map(parseNode2).filter((child) => child !== null);
+    const result = bodyChildren.length === 1 ? bodyChildren[0] : bodyChildren;
+    return JSON.stringify(result);
+  } catch (error) {
+    console.error("Error in html_to_json filter:", error);
+    return input;
+  }
+};
+
+// src/utils/string-utils.ts
+function escapeMarkdown(str) {
+  return str.replace(/([[\]])/g, "\\$1");
+}
+function escapeDoubleQuotes(str) {
+  return str.replace(/"/g, '\\"');
+}
+function sanitizeFileName(fileName) {
+  const platform = navigator.userAgentData?.platform || navigator.platform || "";
+  const isWindows = /win/i.test(platform);
+  const isMac = /mac/i.test(platform);
+  let sanitized = fileName.replace(/[#|\^\[\]]/g, "");
+  if (isWindows) {
+    sanitized = sanitized.replace(/[<>:"\/\\?*\x00-\x1F]/g, "").replace(/^(con|prn|aux|nul|com[0-9]|lpt[0-9])(\..*)?$/i, "_$1$2").replace(/[\s.]+$/, "");
+  } else if (isMac) {
+    sanitized = sanitized.replace(/[\/:\x00-\x1F]/g, "").replace(/^\./, "_");
+  } else {
+    sanitized = sanitized.replace(/[<>:"\/\\|?*\x00-\x1F]/g, "").replace(/^\./, "_");
+  }
+  sanitized = sanitized.replace(/^\.+/, "").trim().slice(0, 245);
+  if (sanitized.length === 0) {
+    sanitized = "Untitled";
+  }
+  return sanitized;
+}
+function getDomain(url) {
+  try {
+    const urlObj = new URL(url);
+    const hostname = urlObj.hostname;
+    if (hostname === "localhost" || hostname === "127.0.0.1" || hostname.match(/^(\d{1,3}\.){3}\d{1,3}$/)) {
+      return hostname;
+    }
+    const hostParts = hostname.split(".");
+    if (hostParts.length > 2) {
+      const lastTwo = hostParts.slice(-2).join(".");
+      if (lastTwo.match(/^(co|com|org|net|edu|gov|mil)\.[a-z]{2}$/)) {
+        return hostParts.slice(-3).join(".");
+      }
+    }
+    return hostParts.slice(-2).join(".");
+  } catch (error) {
+    console.warn("Invalid URL:", url);
+    return "";
+  }
+}
+
+// src/utils/filters/image.ts
+var image = (str, param) => {
+  if (!str.trim()) {
+    return str;
+  }
+  let altText = "";
+  if (param) {
+    param = param.replace(/^\((.*)\)$/, "$1");
+    altText = param.replace(/^(['"])([\s\S]*)\1$/, "$2");
+  }
+  try {
+    const data = JSON.parse(str);
+    const processObject = (obj) => {
+      return Object.entries(obj).map(([key, value]) => {
+        if (typeof value === "object" && value !== null) {
+          return processObject(value);
+        }
+        return `![${escapeMarkdown(String(value))}](${escapeMarkdown(key)})`;
+      }).flat();
+    };
+    if (Array.isArray(data)) {
+      return data.map((item) => {
+        if (typeof item === "object" && item !== null) {
+          return processObject(item);
+        }
+        return item ? `![${altText}](${escapeMarkdown(String(item))})` : "";
+      }).flat();
+    } else if (typeof data === "object" && data !== null) {
+      return processObject(data);
+    }
+  } catch (error) {
+    return `![${altText}](${escapeMarkdown(str)})`;
+  }
+  return str;
+};
+
+// src/utils/filters/join.ts
+var join = (str, param) => {
+  if (!str || str === "undefined" || str === "null") {
+    return "";
+  }
+  let array;
+  try {
+    array = JSON.parse(str);
+  } catch (error) {
+    console.error("Error parsing JSON in join filter:", error);
+    return str;
+  }
+  if (!Array.isArray(array)) {
+    return str;
+  }
+  let separator = ",";
+  if (param) {
+    separator = param.replace(/^(['"])([\s\S]*)\1$/, "$2");
+    separator = separator.replace(/\\n/g, "\n");
+  }
+  return array.join(separator);
+};
+
+// src/utils/filters/kebab.ts
+var kebab = (str) => str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+
+// src/utils/filters/last.ts
+var last = (str) => {
+  if (str === "") {
+    return str;
+  }
+  try {
+    const array = JSON.parse(str);
+    if (Array.isArray(array) && array.length > 0) {
+      return array[array.length - 1].toString();
+    }
+  } catch (error) {
+    console.error("Error parsing JSON in last filter:", error);
+  }
+  return str;
+};
+
+// src/utils/filters/list.ts
+var validListTypes = ["numbered", "task", "numbered-task"];
+var validateListParams = (param) => {
+  if (!param) {
+    return { valid: true };
+  }
+  if (!validListTypes.includes(param)) {
+    return {
+      valid: false,
+      error: `invalid list type "${param}". Use "numbered", "task", or "numbered-task"`
+    };
+  }
+  return { valid: true };
+};
+var list = (input, param) => {
+  if (input === "") {
+    return input;
+  }
+  const processListItem = (item, type, depth = 0) => {
+    const indent = "	".repeat(depth);
+    let prefix;
+    switch (type) {
+      case "numbered":
+        prefix = "1. ";
+        break;
+      case "task":
+        prefix = "- [ ] ";
+        break;
+      case "numbered-task":
+        prefix = "1. [ ] ";
+        break;
+      default:
+        prefix = "- ";
+    }
+    if (Array.isArray(item)) {
+      return processArray(item, type, depth + 1);
+    }
+    return `${indent}${prefix}${item}`;
+  };
+  const processArray = (arr, type, depth = 0) => {
+    return arr.map((item, index) => {
+      let itemType = type;
+      if (type === "numbered" || type === "numbered-task") {
+        const number = index + 1;
+        return processListItem(item, itemType, depth).replace(/^\d+/, number.toString());
+      }
+      return processListItem(item, itemType, depth);
+    }).join("\n");
+  };
+  const determineListType = (param2) => {
+    switch (param2) {
+      case "numbered":
+        return "numbered";
+      case "task":
+        return "task";
+      case "numbered-task":
+        return "numbered-task";
+      default:
+        return "bullet";
+    }
+  };
+  try {
+    const parsedInput = typeof input === "string" ? JSON.parse(input) : input;
+    if (Array.isArray(parsedInput)) {
+      const listType = determineListType(param);
+      return processArray(parsedInput, listType);
+    }
+    return processArray([parsedInput], determineListType(param));
+  } catch (error) {
+    console.error("Error processing list filter:", error);
+    return processListItem(input, determineListType(param));
+  }
+};
+
+// src/utils/filters/link.ts
+var link = (str, param) => {
+  if (!str.trim()) {
+    return str;
+  }
+  let linkText = "link";
+  if (param) {
+    param = param.replace(/^\((.*)\)$/, "$1");
+    linkText = param.replace(/^(['"])([\s\S]*)\1$/, "$2");
+  }
+  const encodeUrl = (url) => {
+    return url.replace(/ /g, "%20");
+  };
+  try {
+    const data = JSON.parse(str);
+    const processObject = (obj) => {
+      return Object.entries(obj).map(([key, value]) => {
+        if (typeof value === "object" && value !== null) {
+          return processObject(value);
+        }
+        return `[${escapeMarkdown(String(value))}](${encodeUrl(escapeMarkdown(key))})`;
+      }).flat();
+    };
+    if (Array.isArray(data)) {
+      const result = data.map((item) => {
+        if (typeof item === "object" && item !== null) {
+          return processObject(item);
+        }
+        return item ? `[${linkText}](${encodeUrl(escapeMarkdown(String(item)))})` : "";
+      });
+      return result.join("\n");
+    } else if (typeof data === "object" && data !== null) {
+      return processObject(data).join("\n");
+    }
+  } catch (error) {
+    return `[${linkText}](${encodeUrl(escapeMarkdown(str))})`;
+  }
+  return str;
+};
+
+// src/utils/filters/length.ts
+var length = (str) => {
+  try {
+    const parsed = JSON.parse(str);
+    if (Array.isArray(parsed)) {
+      return parsed.length.toString();
+    } else if (typeof parsed === "object" && parsed !== null) {
+      return Object.keys(parsed).length.toString();
+    }
+    return str.length.toString();
+  } catch (error) {
+    return str.length.toString();
+  }
+};
+
+// src/utils/filters/lower.ts
+var lower = (input) => {
+  const toLowerCase = (str) => {
+    return str.toLocaleLowerCase();
+  };
+  if (Array.isArray(input)) {
+    return input.map(toLowerCase);
+  } else {
+    return toLowerCase(input);
+  }
+};
+
+// src/utils/filters/map.ts
+var validateMapParams = (param) => {
+  if (!param) {
+    return { valid: false, error: "requires an arrow function (e.g., map:x => x.name)" };
+  }
+  const match = param.match(/^\s*(\w+)\s*=>\s*(.+)$/);
+  if (!match) {
+    return { valid: false, error: "invalid syntax. Use arrow function format (e.g., x => x.name)" };
+  }
+  return { valid: true };
+};
+var map = (str, param) => {
+  debugLog("Map", "map input:", str);
+  debugLog("Map", "map param:", param);
+  let array;
+  try {
+    array = JSON.parse(str);
+    debugLog("Map", "Parsed array:", JSON.stringify(array, null, 2));
+  } catch (error) {
+    debugLog("Map", "Parsing failed, using input as single item");
+    array = [str];
+  }
+  if (Array.isArray(array) && param) {
+    const match = param.match(/^\s*(\w+)\s*=>\s*(.+)$/);
+    if (!match) {
+      debugLog("Map", "Invalid arrow function syntax");
+      return str;
+    }
+    const [, argName, expression] = match;
+    debugLog("Map", "Arrow function parsed:", { argName, expression });
+    const mappedArray = array.map((item, index) => {
+      debugLog("Map", `Processing item ${index}:`, JSON.stringify(item, null, 2));
+      let expr = expression.trim();
+      if (expr.startsWith("(") && expr.endsWith(")")) {
+        expr = expr.slice(1, -1).trim();
+      }
+      if (expr.startsWith("{") && expr.endsWith("}") || expr.startsWith('"') && expr.endsWith('"') || expr.startsWith("'") && expr.endsWith("'")) {
+        const mappedItem = {};
+        if (expr.startsWith("{")) {
+          const assignments = expr.match(/\{(.+)\}/)?.[1].split(",") || [];
+          assignments.forEach((assignment) => {
+            const [key, value] = assignment.split(":").map((s) => s.trim());
+            const cleanKey = key.replace(/^['"](.+)['"]$/, "$1");
+            debugLog("Map", "Processing assignment:", { cleanKey, value });
+            const cleanValue = evaluateExpression(value, item, argName);
+            debugLog("Map", "Cleaned value:", cleanValue);
+            mappedItem[cleanKey] = cleanValue;
+            debugLog("Map", `Assigned ${cleanKey}:`, mappedItem[cleanKey]);
+          });
+        } else {
+          const stringLiteral = expr.slice(1, -1);
+          return stringLiteral.replace(new RegExp(`\\$\\{${argName}\\}`, "g"), item);
+        }
+        debugLog("Map", "Mapped item:", mappedItem);
+        return mappedItem;
+      } else {
+        return evaluateExpression(expression, item, argName);
+      }
+    });
+    debugLog("Map", "Mapped array:", JSON.stringify(mappedArray, null, 2));
+    return JSON.stringify(mappedArray);
+  }
+  debugLog("Map", "map output (unchanged):", str);
+  return str;
+};
+function evaluateExpression(expression, item, argName) {
+  if (typeof item === "string") {
+    return item;
+  }
+  const result = expression.replace(new RegExp(`${argName}\\.([\\w.\\[\\]]+)`, "g"), (_, prop) => {
+    const value = getNestedProperty(item, prop);
+    debugLog("Map", `Replacing ${argName}.${prop} with:`, value);
+    return JSON.stringify(value);
+  });
+  try {
+    return JSON.parse(result);
+  } catch {
+    return result.replace(/^["'](.+)["']$/, "$1");
+  }
+}
+function getNestedProperty(obj, path) {
+  debugLog("Map", "Getting nested property:", { obj: JSON.stringify(obj), path });
+  const result = path.split(/[\.\[\]]/).filter(Boolean).reduce((current, key) => {
+    if (current && Array.isArray(current) && /^\d+$/.test(key)) {
+      return current[parseInt(key, 10)];
+    }
+    return current && current[key] !== void 0 ? current[key] : void 0;
+  }, obj);
+  debugLog("Map", "Nested property result:", result);
+  return result;
+}
+
+// src/utils/filters/markdown.ts
+import { createMarkdownContent } from "defuddle/full";
+var markdown = (str, param) => {
+  const baseUrl = param || "about:blank";
+  try {
+    return createMarkdownContent(str, baseUrl);
+  } catch (error) {
+    console.error("Error in createMarkdownContent:", error);
+    return str;
+  }
+};
+
+// src/utils/filters/merge.ts
+var merge = (str, param) => {
+  if (!str || str === "undefined" || str === "null") {
+    return "[]";
+  }
+  let array;
+  try {
+    array = JSON.parse(str);
+  } catch (error) {
+    console.error("Error parsing JSON in merge filter:", error);
+    return str;
+  }
+  if (!Array.isArray(array)) {
+    array = [str];
+  }
+  if (!param) {
+    return JSON.stringify(array);
+  }
+  param = param.replace(/^\((.*)\)$/, "$1");
+  try {
+    const additionalItems = param.match(/(?:[^,"']+|"[^"]*"|'[^']*')+/g) || [];
+    const processedItems = additionalItems.map((item) => {
+      item = item.trim();
+      return item.replace(/^(['"])([\s\S]*)\1$/, "$2");
+    });
+    return JSON.stringify([...array, ...processedItems]);
+  } catch (error) {
+    console.error("Error processing parameters in merge filter:", error);
+    return JSON.stringify(array);
+  }
+};
+
+// src/utils/filters/nth.ts
+var validateNthParams = (param) => {
+  if (!param) {
+    return { valid: true };
+  }
+  if (param.includes(":")) {
+    const [positions, basis] = param.split(":").map((p) => p.trim());
+    const nthValues = positions.split(",").map((n) => parseInt(n.trim(), 10));
+    const basisSize = parseInt(basis, 10);
+    if (nthValues.some((n) => isNaN(n) || n < 1)) {
+      return { valid: false, error: "positions must be positive numbers (e.g., nth:1,2,3:7)" };
+    }
+    if (isNaN(basisSize) || basisSize < 1) {
+      return { valid: false, error: "basis must be a positive number (e.g., nth:1,2,3:7)" };
+    }
+    return { valid: true };
+  }
+  const expr = param.trim();
+  if (/^\d+$/.test(expr)) {
+    return { valid: true };
+  }
+  if (/^\d+n$/.test(expr)) {
+    return { valid: true };
+  }
+  if (/^n\+\d+$/.test(expr)) {
+    return { valid: true };
+  }
+  return { valid: false, error: "invalid syntax. Use number (2), multiplier (5n), offset (n+7), or basis (1,2:5)" };
+};
+var nth = (str, params) => {
+  if (!str || str === "undefined" || str === "null") {
+    return str;
+  }
+  try {
+    const data = JSON.parse(str);
+    if (!Array.isArray(data)) {
+      return str;
+    }
+    if (!params) {
+      return JSON.stringify(data);
+    }
+    if (params.includes(":")) {
+      const [positions, basis] = params.split(":").map((p) => p.trim());
+      const nthValues = positions.split(",").map((n) => parseInt(n.trim(), 10)).filter((n) => !isNaN(n) && n > 0);
+      const basisSize = parseInt(basis, 10);
+      return JSON.stringify(data.filter((_, index) => {
+        const positionInGroup = index % basisSize + 1;
+        return nthValues.includes(positionInGroup);
+      }));
+    }
+    const nthExpression = params.trim();
+    if (/^\d+$/.test(nthExpression)) {
+      const position = parseInt(nthExpression, 10);
+      return JSON.stringify(data.filter((_, index) => index + 1 === position));
+    }
+    if (/^\d+n$/.test(nthExpression)) {
+      const multiplier = parseInt(nthExpression, 10);
+      return JSON.stringify(data.filter((_, index) => {
+        const position = index + 1;
+        return position % multiplier === 0;
+      }));
+    }
+    const nPlusBMatch = nthExpression.match(/^n\+(\d+)$/);
+    if (nPlusBMatch) {
+      const offset = parseInt(nPlusBMatch[1], 10);
+      return JSON.stringify(data.filter((_, index) => {
+        const position = index + 1;
+        return position >= offset;
+      }));
+    }
+    console.error("Invalid nth filter syntax:", params);
+    return str;
+  } catch (error) {
+    console.error("Error in nth filter:", error);
+    return str;
+  }
+};
+
+// src/utils/filters/number_format.ts
+var number_format = (input, param) => {
+  const formatNumber = (num, decimals, decPoint, thousandsSep) => {
+    const parts = num.toFixed(decimals).split(".");
+    parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, thousandsSep);
+    return parts.join(decPoint);
+  };
+  const processValue = (value, decimals, decPoint, thousandsSep) => {
+    if (typeof value === "number" || typeof value === "string" && !isNaN(parseFloat(value))) {
+      const num = typeof value === "string" ? parseFloat(value) : value;
+      return formatNumber(num, decimals, decPoint, thousandsSep);
+    } else if (Array.isArray(value)) {
+      return value.map((item) => processValue(item, decimals, decPoint, thousandsSep));
+    } else if (typeof value === "object" && value !== null) {
+      const result = {};
+      for (const [key, val] of Object.entries(value)) {
+        result[key] = processValue(val, decimals, decPoint, thousandsSep);
+      }
+      return result;
+    }
+    return value;
+  };
+  const unescapeString = (str) => {
+    return str.replace(/\\(.)/g, "$1");
+  };
+  try {
+    let decimals = 0;
+    let decPoint = ".";
+    let thousandsSep = ",";
+    if (param) {
+      const cleanParam = param.replace(/^\((.*)\)$/, "$1");
+      const params = [];
+      let current = "";
+      let inQuote = false;
+      let escapeNext = false;
+      for (let i = 0; i < cleanParam.length; i++) {
+        const char = cleanParam[i];
+        if (escapeNext) {
+          current += char;
+          escapeNext = false;
+        } else if (char === "\\") {
+          current += char;
+          escapeNext = true;
+        } else if (char === '"' && !inQuote) {
+          inQuote = true;
+        } else if (char === '"' && inQuote) {
+          inQuote = false;
+        } else if (char === "," && !inQuote) {
+          params.push(current.trim());
+          current = "";
+        } else {
+          current += char;
+        }
+      }
+      if (current) {
+        params.push(current.trim());
+      }
+      if (params.length >= 1) decimals = parseInt(params[0], 10);
+      if (params.length >= 2) decPoint = unescapeString(params[1].replace(/^["'](.*)["']$/, "$1"));
+      if (params.length >= 3) thousandsSep = unescapeString(params[2].replace(/^["'](.*)["']$/, "$1"));
+    }
+    if (isNaN(decimals)) decimals = 0;
+    let parsedInput;
+    try {
+      parsedInput = JSON.parse(input);
+    } catch {
+      parsedInput = input;
+    }
+    const result = processValue(parsedInput, decimals, decPoint, thousandsSep);
+    return typeof result === "string" ? result : JSON.stringify(result);
+  } catch (error) {
+    console.error("Error in number_format filter:", error);
+    return input;
+  }
+};
+
+// src/utils/filters/object.ts
+var validObjectParams = ["array", "keys", "values"];
+var validateObjectParams = (param) => {
+  if (!param) {
+    return { valid: false, error: 'requires a parameter: "array", "keys", or "values"' };
+  }
+  if (!validObjectParams.includes(param)) {
+    return {
+      valid: false,
+      error: `invalid parameter "${param}". Use "array", "keys", or "values"`
+    };
+  }
+  return { valid: true };
+};
+var object = (str, param) => {
+  try {
+    const obj = JSON.parse(str);
+    if (typeof obj === "object" && obj !== null) {
+      switch (param) {
+        case "array":
+          return JSON.stringify(Object.entries(obj));
+        case "keys":
+          return JSON.stringify(Object.keys(obj));
+        case "values":
+          return JSON.stringify(Object.values(obj));
+        default:
+          return str;
+      }
+    }
+  } catch (error) {
+    console.error("Error parsing JSON for object filter:", error);
+  }
+  return str;
+};
+
+// src/utils/filters/pascal.ts
+var pascal = (str) => str.replace(/[\s_-]+(.)/g, (_, c) => c.toUpperCase()).replace(/^(.)/, (c) => c.toUpperCase());
+
+// src/utils/filters/reverse.ts
+var reverse = (str) => {
+  if (!str || str === "undefined" || str === "null") {
+    return "";
+  }
+  try {
+    const value = JSON.parse(str);
+    if (Array.isArray(value)) {
+      return JSON.stringify(value.reverse());
+    } else if (typeof value === "object" && value !== null) {
+      const entries = Object.entries(value);
+      const reversedEntries = entries.reverse();
+      const reversedObject = Object.fromEntries(reversedEntries);
+      return JSON.stringify(reversedObject);
+    }
+  } catch (error) {
+    return str.split("").reverse().join("");
+  }
+  return str;
+};
+
+// src/utils/filters/remove_attr.ts
+var remove_attr = (html, removeAttributes = "") => {
+  if (!removeAttributes) {
+    return html;
+  }
+  removeAttributes = removeAttributes.replace(/^\((.*)\)$/, "$1");
+  removeAttributes = removeAttributes.replace(/^(['"])([\s\S]*)\1$/, "$2").replace(/\\(['"])/g, "$1");
+  const removeAttributesList = removeAttributes.split(",").map((attr) => attr.trim().toLowerCase()).filter(Boolean);
+  if (removeAttributesList.length === 0) {
+    return html;
+  }
+  return html.replace(/<(\w+)\s+([^>]*?)>/g, (match, tag, attributesString) => {
+    const attributeOrSlashRegex = /([a-zA-Z0-9_:-]+(?:\s*=\s*(?:"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|[^'"\s>]+))?)|(\s*\/?\s*$)/g;
+    const attributeNameExtractorRegex = /^([a-zA-Z0-9_:-]+)/;
+    const elementsToKeep = [];
+    const allMatches = Array.from(attributesString.matchAll(attributeOrSlashRegex));
+    for (const currentMatch of allMatches) {
+      const fullMatchedText = currentMatch[0];
+      const attributePart = currentMatch[1];
+      const slashPart = currentMatch[2];
+      if (attributePart) {
+        const nameMatch = attributePart.match(attributeNameExtractorRegex);
+        if (nameMatch) {
+          const attrName = nameMatch[0];
+          const shouldRemove = removeAttributesList.includes(attrName.toLowerCase());
+          if (!shouldRemove) {
+            elementsToKeep.push(attributePart);
+          }
+        } else {
+          elementsToKeep.push(attributePart);
+        }
+      } else if (slashPart && fullMatchedText && fullMatchedText.includes("/")) {
+        elementsToKeep.push(fullMatchedText.trim());
+      }
+    }
+    const cleanedAttributes = elementsToKeep.join(" ").trim();
+    return cleanedAttributes ? `<${tag} ${cleanedAttributes}>` : `<${tag}>`;
+  });
+};
+
+// src/utils/filters/remove_html.ts
+var remove_html = (html, params = "") => {
+  debugLog("RemoveHTML", "Input:", { html, params });
+  params = params.replace(/^\((.*)\)$/, "$1");
+  params = params.replace(/^(['"])([\s\S]*)\1$/, "$2").replace(/\\(['"])/g, "$1");
+  const elementsToRemove = params.split(/,(?=(?:(?:[^"']*["'][^"']*["'])*[^"']*$))/).map((elem) => elem.trim()).filter(Boolean);
+  debugLog("RemoveHTML", "Elements to remove:", elementsToRemove);
+  if (elementsToRemove.length === 0) {
+    return html;
+  }
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(html, "text/html");
+  elementsToRemove.forEach((elem) => {
+    let elements;
+    if (elem.startsWith(".")) {
+      elements = doc.querySelectorAll(`[class*="${elem.slice(1)}"]`);
+    } else if (elem.startsWith("#")) {
+      elements = doc.querySelectorAll(`[id="${elem.slice(1)}"]`);
+    } else {
+      elements = doc.getElementsByTagName(elem);
+    }
+    Array.from(elements).forEach((el) => el.parentNode?.removeChild(el));
+  });
+  const serializer = new XMLSerializer();
+  let result = "";
+  Array.from(doc.body.childNodes).forEach((node) => {
+    if (node.nodeType === Node.ELEMENT_NODE) {
+      result += serializer.serializeToString(node);
+    } else if (node.nodeType === Node.TEXT_NODE) {
+      result += node.textContent;
+    }
+  });
+  debugLog("RemoveHTML", "Output:", result);
+  return result;
+};
+
+// src/utils/filters/remove_tags.ts
+var remove_tags = (html, removeTags = "") => {
+  if (!removeTags) {
+    return html;
+  }
+  removeTags = removeTags.replace(/^\((.*)\)$/, "$1");
+  removeTags = removeTags.replace(/^(['"])([\s\S]*)\1$/, "$2").replace(/\\(['"])/g, "$1");
+  const removeTagsList = removeTags.split(",").map((tag) => tag.trim()).filter(Boolean);
+  if (removeTagsList.length === 0) {
+    return html;
+  }
+  const escapedTags = removeTagsList.map((tag) => tag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+  const regex = new RegExp(`<\\/?(?:${escapedTags})\\b[^>]*>`, "gi");
+  return html.replace(regex, "");
+};
+
+// src/utils/filters/replace.ts
+var validateReplaceParams = (param) => {
+  if (!param) {
+    return { valid: false, error: 'requires search and replacement (e.g., replace:"old":"new")' };
+  }
+  const cleanParam = param.replace(/^\((.*)\)$/, "$1");
+  const hasQuotedPair = /["'][^"']*["']\s*:\s*["'][^"']*["']/.test(cleanParam) || /["'][^"']*["']\s*:/.test(cleanParam) || // "search": with implicit empty replacement
+  /\/[^/]+\/[gimsuy]*\s*:/.test(cleanParam);
+  if (!hasQuotedPair) {
+    return {
+      valid: false,
+      error: 'values must be quoted (e.g., replace:"old":"new" or replace:"text":"")'
+    };
+  }
+  return { valid: true };
+};
+var replace = (str, param) => {
+  if (!param) {
+    return str;
+  }
+  param = param.replace(/^\((.*)\)$/, "$1");
+  const replacements = [];
+  const state = createParserState();
+  for (let i = 0; i < param.length; i++) {
+    const char = param[i];
+    if (char === "," && !state.inQuote && !state.inRegex && state.curlyDepth === 0 && state.parenDepth === 0) {
+      replacements.push(state.current.trim());
+      state.current = "";
+    } else {
+      processCharacter(char, state);
+    }
+  }
+  if (state.current) {
+    replacements.push(state.current.trim());
+  }
+  return replacements.reduce((acc, replacement) => {
+    let [search, replace2] = replacement.split(/(?<=[^\\]["']):(?=["'])/).map((p) => {
+      return p.trim().replace(/^["']|["']$/g, "");
+    });
+    replace2 = replace2 || "";
+    const regexInfo = parseRegexPattern(search);
+    if (regexInfo) {
+      try {
+        replace2 = processEscapedCharacters(replace2);
+        const regex = new RegExp(regexInfo.pattern, regexInfo.flags);
+        return acc.replace(regex, replace2);
+      } catch (error) {
+        console.error("Invalid regex pattern:", error);
+        return acc;
+      }
+    }
+    search = processEscapedCharacters(search);
+    replace2 = processEscapedCharacters(replace2);
+    if (search === "|" || search === ":") {
+      return acc.split(search).join(replace2);
+    }
+    if (search.includes("\n") || search.includes("\r") || search.includes("	")) {
+      return acc.split(search).join(replace2);
+    }
+    const searchRegex = new RegExp(search.replace(/([.*+?^${}()[\]\\])/g, "\\$1"), "g");
+    return acc.replace(searchRegex, replace2);
+  }, str);
+};
+function processEscapedCharacters(str) {
+  return str.replace(/\\([nrt]|[^nrt])/g, (match, char) => {
+    switch (char) {
+      case "n":
+        return "\n";
+      case "r":
+        return "\r";
+      case "t":
+        return "	";
+      default:
+        return char;
+    }
+  });
+}
+
+// src/utils/filters/replace_tags.ts
+var replace_tags = (html, params = "") => {
+  params = params.replace(/^\((.*)\)$/, "$1");
+  params = params.replace(/^(['"])([\s\S]*)\1$/, "$2").replace(/\\(['"])/g, "$1");
+  const transformations = params.split(/,(?=(?:(?:[^"']*["'][^"']*["'])*[^"']*$))/).map((transform) => transform.trim()).filter(Boolean);
+  if (transformations.length === 0) {
+    return html;
+  }
+  let result = html;
+  transformations.forEach((transform) => {
+    const [source, target] = transform.split(/(?<!\\)":"/).map((tag) => {
+      return tag.trim().replace(/^["']|["']$/g, "").replace(/\\(.)/g, "$1");
+    });
+    if (!source) {
+      return;
+    }
+    const openingPattern = new RegExp(`<${source}(\\s+[^>]*?)?>`, "g");
+    const closingPattern = new RegExp(`</${source}>`, "g");
+    result = result.replace(openingPattern, (match, attributes) => {
+      return target ? `<${target}${attributes || ""}>` : "";
+    }).replace(closingPattern, target ? `</${target}>` : "");
+  });
+  return result;
+};
+
+// src/utils/filters/round.ts
+var validateRoundParams = (param) => {
+  if (!param) {
+    return { valid: true };
+  }
+  const num = parseInt(param, 10);
+  if (isNaN(num)) {
+    return { valid: false, error: "decimal places must be a number (e.g., round:2)" };
+  }
+  if (num < 0) {
+    return { valid: false, error: "decimal places must be non-negative (e.g., round:2)" };
+  }
+  return { valid: true };
+};
+var round = (input, param) => {
+  const roundNumber = (num, decimalPlaces) => {
+    if (decimalPlaces === void 0) {
+      return Math.round(num);
+    }
+    const factor = Math.pow(10, decimalPlaces);
+    return Math.round(num * factor) / factor;
+  };
+  const processValue = (value, decimalPlaces) => {
+    if (typeof value === "number") {
+      return roundNumber(value, decimalPlaces);
+    } else if (typeof value === "string") {
+      const num = parseFloat(value);
+      return isNaN(num) ? value : roundNumber(num, decimalPlaces).toString();
+    } else if (Array.isArray(value)) {
+      return value.map((item) => processValue(item, decimalPlaces));
+    } else if (typeof value === "object" && value !== null) {
+      const result = {};
+      for (const [key, val] of Object.entries(value)) {
+        result[key] = processValue(val, decimalPlaces);
+      }
+      return result;
+    }
+    return value;
+  };
+  try {
+    const decimalPlaces = param ? parseInt(param, 10) : void 0;
+    if (param !== void 0 && isNaN(Number(param))) {
+      return input;
+    }
+    let parsedInput;
+    try {
+      parsedInput = JSON.parse(input);
+    } catch {
+      parsedInput = input;
+    }
+    const result = processValue(parsedInput, decimalPlaces);
+    return typeof result === "string" ? result : JSON.stringify(result);
+  } catch (error) {
+    console.error("Error in round filter:", error);
+    return input;
+  }
+};
+
+// src/utils/filters/safe_name.ts
+var validOsParams = ["windows", "mac", "linux"];
+var validateSafeNameParams = (param) => {
+  if (!param) {
+    return { valid: true };
+  }
+  if (!validOsParams.includes(param.toLowerCase().trim())) {
+    return {
+      valid: false,
+      error: `invalid OS "${param}". Use "windows", "mac", or "linux"`
+    };
+  }
+  return { valid: true };
+};
+var safe_name = (str, param) => {
+  const os = param ? param.toLowerCase().trim() : "default";
+  let sanitized = str;
+  sanitized = sanitized.replace(/[#|\^\[\]]/g, "");
+  switch (os) {
+    case "windows":
+      sanitized = sanitized.replace(/[<>:"\/\\|?*\x00-\x1F]/g, "").replace(/^(con|prn|aux|nul|com[0-9]|lpt[0-9])(\..*)?$/i, "_$1$2").replace(/[\s.]+$/, "");
+      break;
+    case "mac":
+      sanitized = sanitized.replace(/[\/:\x00-\x1F]/g, "").replace(/^\./, "_");
+      break;
+    case "linux":
+      sanitized = sanitized.replace(/[\/\x00-\x1F]/g, "").replace(/^\./, "_");
+      break;
+    default:
+      sanitized = sanitized.replace(/[<>:"\/\\|?*:\x00-\x1F]/g, "").replace(/^(con|prn|aux|nul|com[0-9]|lpt[0-9])(\..*)?$/i, "_$1$2").replace(/[\s.]+$/, "").replace(/^\./, "_");
+      break;
+  }
+  sanitized = sanitized.replace(/^\.+/, "").slice(0, 245);
+  if (sanitized.length === 0) {
+    sanitized = "Untitled";
+  }
+  return sanitized;
+};
+
+// src/utils/filters/slice.ts
+var validateSliceParams = (param) => {
+  if (!param) {
+    return { valid: false, error: "requires at least a start index (e.g., slice:0,5)" };
+  }
+  const parts = param.split(",").map((p) => p.trim());
+  if (parts.length > 2) {
+    return { valid: false, error: "accepts at most 2 parameters: start and end" };
+  }
+  for (const part of parts) {
+    if (part !== "" && isNaN(parseInt(part, 10))) {
+      return { valid: false, error: `"${part}" is not a valid number` };
+    }
+  }
+  return { valid: true };
+};
+var slice = (str, param) => {
+  if (!param) {
+    console.error("Slice filter requires parameters");
+    return str;
+  }
+  if (str === "") {
+    return str;
+  }
+  const [start, end] = param.split(",").map((p) => p.trim()).map((p) => {
+    if (p === "") return void 0;
+    const num = parseInt(p, 10);
+    return isNaN(num) ? void 0 : num;
+  });
+  let value;
+  try {
+    value = JSON.parse(str);
+  } catch (error) {
+    if (str.startsWith("[") || str.startsWith("{")) {
+      console.error("Error parsing JSON in slice filter:", error);
+    }
+    value = str;
+  }
+  if (Array.isArray(value)) {
+    const slicedArray = value.slice(start, end);
+    if (slicedArray.length === 1) {
+      return slicedArray[0].toString();
+    }
+    return JSON.stringify(slicedArray);
+  } else {
+    const slicedString = str.slice(start, end);
+    return slicedString;
+  }
+};
+
+// src/utils/filters/snake.ts
+var snake = (str) => str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toLowerCase();
+
+// src/utils/filters/split.ts
+var split = (str, param) => {
+  if (!param || param === "") {
+    return JSON.stringify(str.split(""));
+  }
+  param = param.replace(/^\((.*)\)$/, "$1");
+  param = param.replace(/^(['"])([\s\S]*)\1$/, "$2");
+  const separator = param.length === 1 ? param : new RegExp(param);
+  const result = str.split(separator);
+  return JSON.stringify(result);
+};
+
+// src/utils/filters/strip_attr.ts
+var strip_attr = (html, keepAttributes = "") => {
+  keepAttributes = keepAttributes.replace(/^\((.*)\)$/, "$1");
+  keepAttributes = keepAttributes.replace(/^(['"])([\s\S]*)\1$/, "$2").replace(/\\(['"])/g, "$1");
+  const keepAttributesList = keepAttributes.split(",").map((attr) => attr.trim()).filter(Boolean);
+  return html.replace(/<(\w+)\s+(?:[^>]*?)>/g, (match, tag) => {
+    if (keepAttributesList.length === 0) {
+      return `<${tag}>`;
+    }
+    const keepAttrs = keepAttributesList.map((attr) => {
+      const escapedAttr = attr.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const regex = new RegExp(`\\s${escapedAttr}\\s*=\\s*("[^"]*"|'[^']*')`, "i");
+      const attrMatch = match.match(regex);
+      return attrMatch ? attrMatch[0].trim() : "";
+    }).filter(Boolean).join(" ");
+    return keepAttrs ? `<${tag} ${keepAttrs}>` : `<${tag}>`;
+  });
+};
+
+// src/utils/filters/strip_tags.ts
+var strip_tags = (html, keepTags = "") => {
+  keepTags = keepTags.replace(/^\((.*)\)$/, "$1");
+  keepTags = keepTags.replace(/^(['"])([\s\S]*)\1$/, "$2").replace(/\\(['"])/g, "$1");
+  const keepTagsList = keepTags.split(",").map((tag) => tag.trim()).filter(Boolean);
+  let result;
+  if (keepTagsList.length === 0) {
+    result = html.replace(/<\/?[^>]+(>|$)/g, "");
+  } else {
+    const escapedTags = keepTagsList.map((tag) => tag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+    const regex = new RegExp(`<(?!\\/?(?:${escapedTags})\\b)[^>]+>`, "gi");
+    result = html.replace(regex, "");
+  }
+  result = result.replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&ldquo;/g, '"').replace(/&rdquo;/g, '"').replace(/&lsquo;/g, "'").replace(/&rsquo;/g, "'").replace(/&mdash;/g, "\u2014").replace(/&ndash;/g, "\u2013").replace(/&hellip;/g, "\u2026").replace(/&#(\d+);/g, (match, dec) => String.fromCharCode(Number(dec))).replace(/&#x([0-9A-Fa-f]+);/g, (match, hex) => String.fromCharCode(parseInt(hex, 16)));
+  result = result.replace(/\n{3,}/g, "\n\n");
+  return result.trim();
+};
+
+// src/utils/filters/table.ts
+var table = (str, params) => {
+  if (!str || str === "undefined" || str === "null") {
+    return str;
+  }
+  try {
+    const data = JSON.parse(str);
+    let customHeaders = [];
+    if (params) {
+      try {
+        const headerStr = params.replace(/^\((.*)\)$/, "$1");
+        customHeaders = headerStr.split(",").map(
+          (header) => header.trim().replace(/^["'](.*)["']$/, "$1")
+        );
+      } catch (error) {
+        console.error("Error parsing table headers:", error);
+      }
+    }
+    const escapeCell = (cell) => cell.replace(/\|/g, "\\|");
+    if (typeof data === "object" && data !== null && !Array.isArray(data)) {
+      const entries = Object.entries(data);
+      if (entries.length === 0) return str;
+      const [[firstKey, firstValue], ...restEntries] = entries;
+      let table2 = `| ${escapeCell(firstKey)} | ${escapeCell(String(firstValue))} |
+| - | - |
+`;
+      restEntries.forEach(([key, value]) => {
+        table2 += `| ${escapeCell(key)} | ${escapeCell(String(value))} |
+`;
+      });
+      return table2.trim();
+    }
+    if (Array.isArray(data) && data.length > 0 && typeof data[0] === "object" && data[0] !== null) {
+      const headers = customHeaders.length > 0 ? customHeaders : Object.keys(data[0]);
+      let table2 = `| ${headers.join(" | ")} |
+| ${headers.map(() => "-").join(" | ")} |
+`;
+      data.forEach((row) => {
+        table2 += `| ${headers.map((header) => escapeCell(String(row[header] || ""))).join(" | ")} |
+`;
+      });
+      return table2.trim();
+    }
+    if (Array.isArray(data) && data.length > 0 && Array.isArray(data[0])) {
+      const maxColumns = Math.max(...data.map((row) => row.length));
+      const headers = customHeaders.length > 0 ? customHeaders : Array(maxColumns).fill("");
+      let table2 = `| ${headers.join(" | ")} |
+| ${headers.map(() => "-").join(" | ")} |
+`;
+      data.forEach((row) => {
+        const paddedRow = [...row, ...Array(maxColumns - row.length).fill("")];
+        table2 += `| ${paddedRow.map((cell) => escapeCell(String(cell))).join(" | ")} |
+`;
+      });
+      return table2.trim();
+    }
+    if (Array.isArray(data)) {
+      if (customHeaders.length > 0) {
+        const numColumns = customHeaders.length;
+        let table3 = `| ${customHeaders.join(" | ")} |
+| ${customHeaders.map(() => "-").join(" | ")} |
+`;
+        for (let i = 0; i < data.length; i += numColumns) {
+          const row = data.slice(i, i + numColumns);
+          const paddedRow = [...row, ...Array(numColumns - row.length).fill("")];
+          table3 += `| ${paddedRow.map((cell) => escapeCell(String(cell))).join(" | ")} |
+`;
+        }
+        return table3.trim();
+      }
+      let table2 = "| Value |\n| - |\n";
+      data.forEach((item) => {
+        table2 += `| ${escapeCell(String(item))} |
+`;
+      });
+      return table2.trim();
+    }
+    return str;
+  } catch (error) {
+    console.error("Error parsing JSON for table filter:", error);
+    return str;
+  }
+};
+
+// src/utils/filters/template.ts
+var validateTemplateParams = (param) => {
+  if (!param) {
+    return { valid: false, error: 'requires a template string (e.g., template:"${name}")' };
+  }
+  return { valid: true };
+};
+var template = (input, param) => {
+  debugLog("Template", "Template input:", input);
+  debugLog("Template", "Template param:", param);
+  if (!param) {
+    debugLog("Template", "No param provided, returning input");
+    return typeof input === "string" ? input : JSON.stringify(input);
+  }
+  param = param.replace(/^\((.*)\)$/, "$1");
+  param = param.replace(/^(['"])([\s\S]*)\1$/, "$2");
+  let obj = [];
+  if (typeof input === "string") {
+    try {
+      obj = JSON.parse(input);
+      debugLog("Template", "Parsed input:", obj);
+    } catch (error) {
+      debugLog("Template", "Parsing failed, using input as is");
+      obj = [input];
+    }
+  } else {
+    obj = input;
+  }
+  obj = Array.isArray(obj) ? obj : [obj];
+  debugLog("Template", "Object to process:", obj);
+  const result = obj.map((item) => replaceTemplateVariables(item, param)).join("\n\n");
+  debugLog("Template", "Processing result:", result);
+  return result;
+};
+function replaceTemplateVariables(obj, template2) {
+  debugLog("Template", "Replacing template variables for:", obj);
+  debugLog("Template", "Template:", template2);
+  if (typeof obj === "string") {
+    const strValue = obj;
+    try {
+      obj = parseObjectString(obj);
+      debugLog("Template", "Parsed object:", obj);
+    } catch (error) {
+      debugLog("Template", "Failed to parse object string:", obj);
+    }
+    if (obj.str === void 0) {
+      obj.str = strValue;
+    }
+  }
+  let result = template2.replace(/\$\{([\w.]+)\}/g, (match, path) => {
+    debugLog("Template", "Replacing:", match);
+    const value = getNestedProperty2(obj, path);
+    debugLog("Template", "Replaced with:", value);
+    return value !== void 0 && value !== "undefined" ? value : "";
+  });
+  debugLog("Template", "Result after variable replacement:", result);
+  result = result.replace(/\\n/g, "\n");
+  debugLog("Template", "Result after newline replacement:", result);
+  result = result.split("\n").filter((line) => line.trim() !== "").join("\n");
+  debugLog("Template", "Result after empty line removal:", result);
+  return result.trim();
+}
+function parseObjectString(str) {
+  const obj = {};
+  const regex = /(\w+):\s*("(?:\\.|[^"\\])*"|[^,}]+)/g;
+  let match;
+  while ((match = regex.exec(str)) !== null) {
+    let [, key, value] = match;
+    if (value.startsWith('"') && value.endsWith('"')) {
+      value = value.slice(1, -1);
+    }
+    obj[key] = value === "undefined" ? void 0 : value;
+  }
+  return obj;
+}
+function getNestedProperty2(obj, path) {
+  debugLog("Template", "Getting nested property:", { obj, path });
+  const result = path.split(".").reduce((current, key) => {
+    return current && typeof current === "object" ? current[key] : void 0;
+  }, obj);
+  debugLog("Template", "Nested property result:", result);
+  return result;
+}
+
+// src/utils/filters/title.ts
+var lowercaseWords = ["a", "an", "the", "and", "but", "or", "for", "nor", "on", "at", "to", "from", "by", "in", "of"];
+var title = (input, param) => {
+  const toTitleCase = (str) => {
+    return str.split(/\s+/).map((word, index) => {
+      if (index !== 0 && lowercaseWords.includes(word.toLowerCase())) {
+        return word.toLowerCase();
+      }
+      return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+    }).join(" ");
+  };
+  const processValue = (value) => {
+    if (typeof value === "string") {
+      return toTitleCase(value);
+    } else if (Array.isArray(value)) {
+      return value.map(processValue);
+    } else if (typeof value === "object" && value !== null) {
+      const result = {};
+      for (const [key, val] of Object.entries(value)) {
+        result[toTitleCase(key)] = processValue(val);
+      }
+      return result;
+    }
+    return value;
+  };
+  try {
+    const parsedInput = JSON.parse(input);
+    const result = processValue(parsedInput);
+    return JSON.stringify(result);
+  } catch (error) {
+    return processValue(input);
+  }
+};
+
+// src/utils/filters/trim.ts
+var trim = (str) => {
+  return str.trim();
+};
+
+// src/utils/filters/uncamel.ts
+var uncamel = (str) => {
+  const spaced = str.replace(/([a-z0-9])([A-Z])/g, "$1 $2");
+  return spaced.replace(/([A-Z])([A-Z][a-z])/g, "$1 $2").toLowerCase();
+};
+
+// src/utils/filters/unescape.ts
+var unescape = (str) => str.replace(/\\"/g, '"').replace(/\\n/g, "\n");
+
+// src/utils/filters/unique.ts
+var unique = (input) => {
+  try {
+    const parsed = JSON.parse(input);
+    if (Array.isArray(parsed)) {
+      if (parsed.every((item) => typeof item !== "object")) {
+        return JSON.stringify([...new Set(parsed)]);
+      }
+      const seen = /* @__PURE__ */ new Set();
+      const uniqueArray = parsed.filter((item) => {
+        const stringified = JSON.stringify(item);
+        if (seen.has(stringified)) {
+          return false;
+        }
+        seen.add(stringified);
+        return true;
+      });
+      return JSON.stringify(uniqueArray);
+    }
+    if (typeof parsed === "object" && parsed !== null) {
+      const reverseEntries = Object.entries(parsed).reverse();
+      const seen = /* @__PURE__ */ new Set();
+      const uniqueEntries = reverseEntries.filter(([_, value]) => {
+        const stringified = JSON.stringify(value);
+        if (seen.has(stringified)) {
+          return false;
+        }
+        seen.add(stringified);
+        return true;
+      }).reverse();
+      return JSON.stringify(Object.fromEntries(uniqueEntries));
+    }
+    return input;
+  } catch {
+    return input;
+  }
+};
+
+// src/utils/filters/upper.ts
+var upper = (input) => {
+  const toUpperCase = (str) => {
+    return str.toLocaleUpperCase();
+  };
+  if (Array.isArray(input)) {
+    return input.map(toUpperCase);
+  } else {
+    return toUpperCase(input);
+  }
+};
+
+// src/utils/filters/wikilink.ts
+var wikilink = (str, param) => {
+  if (!str.trim()) {
+    return str;
+  }
+  let alias = "";
+  if (param) {
+    param = param.replace(/^\((.*)\)$/, "$1");
+    alias = param.replace(/^(['"])([\s\S]*)\1$/, "$2");
+  }
+  try {
+    const data = JSON.parse(str);
+    const processObject = (obj) => {
+      return Object.entries(obj).map(([key, value]) => {
+        if (typeof value === "object" && value !== null) {
+          return processObject(value);
+        }
+        return `[[${key}|${value}]]`;
+      }).flat();
+    };
+    if (Array.isArray(data)) {
+      const result = data.flatMap((item) => {
+        if (typeof item === "object" && item !== null) {
+          return processObject(item);
+        }
+        return item ? alias ? `[[${item}|${alias}]]` : `[[${item}]]` : "";
+      });
+      return JSON.stringify(result);
+    } else if (typeof data === "object" && data !== null) {
+      return JSON.stringify(processObject(data));
+    }
+  } catch (error) {
+    return alias ? `[[${str}|${alias}]]` : `[[${str}]]`;
+  }
+  return str;
+};
+
+// src/utils/filters/duration.ts
+import dayjs3 from "dayjs";
+import durationPlugin from "dayjs/plugin/duration";
+dayjs3.extend(durationPlugin);
+var duration = (str, param) => {
+  if (!str) {
+    return str;
+  }
+  try {
+    str = str.replace(/^["'](.*)["']$/g, "$1");
+    const matches = str.match(/^P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/);
+    if (!matches) {
+      const seconds2 = parseInt(str, 10);
+      if (!isNaN(seconds2)) {
+        return formatDuration(dayjs3.duration(seconds2, "seconds"), param);
+      }
+      return str;
+    }
+    const [, years, months, days, hours, minutes, seconds] = matches;
+    const totalSeconds = (years ? parseInt(years) * 365 * 24 * 3600 : 0) + (months ? parseInt(months) * 30 * 24 * 3600 : 0) + (days ? parseInt(days) * 24 * 3600 : 0) + (hours ? parseInt(hours) * 3600 : 0) + (minutes ? parseInt(minutes) * 60 : 0) + (seconds ? parseInt(seconds) : 0);
+    const dur = dayjs3.duration(totalSeconds, "seconds");
+    return formatDuration(dur, param);
+  } catch (error) {
+    console.error("Error in duration filter:", error);
+    return str;
+  }
+};
+function formatDuration(dur, format) {
+  if (!format) {
+    if (dur.asHours() >= 1) {
+      format = "HH:mm:ss";
+    } else {
+      format = "mm:ss";
+    }
+  }
+  format = format.replace(/^["'(](.*)["')]$/g, "$1");
+  const hours = Math.floor(dur.asHours());
+  const minutes = dur.minutes();
+  const seconds = dur.seconds();
+  const parts = {
+    "HH": padZero(hours),
+    "H": hours.toString(),
+    "mm": padZero(minutes),
+    "m": minutes.toString(),
+    "ss": padZero(seconds),
+    "s": seconds.toString()
+  };
+  return format.replace(/HH|H|mm|m|ss|s/g, (match) => parts[match].toString());
+}
+function padZero(num) {
+  return num.toString().padStart(2, "0");
+}
+
+// src/utils/filters.ts
+var filterMetadata = {
+  // Filters with validators
+  calc: { example: 'calc:"+10"', validateParams: validateCalcParams },
+  date_modify: { example: 'date_modify:"+1 day"', validateParams: validateDateModifyParams },
+  map: { example: "map:x => x.name", validateParams: validateMapParams },
+  replace: { example: 'replace:"old":"new"', validateParams: validateReplaceParams },
+  slice: { example: "slice:0,5", validateParams: validateSliceParams },
+  template: { example: 'template:"${name}"', validateParams: validateTemplateParams },
+  // Filters with optional parameters (examples for documentation)
+  blockquote: {},
+  callout: { example: "callout:info" },
+  camel: {},
+  capitalize: {},
+  date: { example: 'date:"YYYY-MM-DD"' },
+  decode_uri: {},
+  duration: {},
+  first: {},
+  footnote: {},
+  fragment_link: {},
+  html_to_json: {},
+  image: {},
+  join: { example: 'join:", "' },
+  kebab: {},
+  last: {},
+  length: {},
+  link: {},
+  list: { example: "list:numbered", validateParams: validateListParams },
+  lower: {},
+  markdown: {},
+  merge: {},
+  nth: { example: "nth:2", validateParams: validateNthParams },
+  number_format: {},
+  object: { example: "object:keys", validateParams: validateObjectParams },
+  pascal: {},
+  remove_attr: {},
+  remove_html: {},
+  remove_tags: {},
+  replace_tags: {},
+  reverse: {},
+  round: { example: "round:2", validateParams: validateRoundParams },
+  safe_name: { example: "safe_name:windows", validateParams: validateSafeNameParams },
+  snake: {},
+  split: { example: 'split:","' },
+  strip_attr: {},
+  strip_md: {},
+  strip_tags: {},
+  stripmd: {},
+  table: {},
+  title: {},
+  trim: {},
+  uncamel: {},
+  unescape: {},
+  unique: {},
+  upper: {},
+  wikilink: {}
+};
+var validFilterNames = new Set(Object.keys(filterMetadata));
+var filters = {
+  blockquote,
+  calc,
+  callout,
+  camel,
+  capitalize,
+  date_modify,
+  date,
+  decode_uri,
+  duration,
+  first,
+  footnote,
+  fragment_link,
+  html_to_json,
+  image,
+  join,
+  kebab,
+  last,
+  length,
+  link,
+  list,
+  lower,
+  map,
+  markdown,
+  merge,
+  number_format,
+  nth,
+  object,
+  pascal,
+  reverse,
+  remove_attr,
+  remove_html,
+  remove_tags,
+  replace,
+  replace_tags,
+  round,
+  safe_name,
+  slice,
+  snake,
+  split,
+  strip_attr,
+  strip_md,
+  strip_tags,
+  stripmd: strip_md,
+  // an alias for strip_md
+  table,
+  template,
+  title,
+  trim,
+  uncamel,
+  unescape,
+  unique,
+  upper,
+  wikilink
+};
+function splitFilterString(filterString) {
+  const filters2 = [];
+  const state = createParserState();
+  filterString = filterString.replace(/\s*\|\s*(?=(?:[^"'()]*["'][^"'()]*["'])*[^"'()]*$)/g, "|");
+  for (let i = 0; i < filterString.length; i++) {
+    const char = filterString[i];
+    if (char === "|" && !state.inQuote && !state.inRegex && state.curlyDepth === 0 && state.parenDepth === 0) {
+      filters2.push(state.current.trim());
+      state.current = "";
+    } else {
+      processCharacter(char, state);
+    }
+  }
+  if (state.current) {
+    filters2.push(state.current.trim());
+  }
+  return filters2;
+}
+function parseFilterString(filterString) {
+  const parts = [];
+  const state = createParserState();
+  for (let i = 0; i < filterString.length; i++) {
+    const char = filterString[i];
+    if (char === ":" && !state.inQuote && !state.inRegex && state.parenDepth === 0 && parts.length === 0) {
+      parts.push(state.current.trim());
+      state.current = "";
+    } else {
+      processCharacter(char, state);
+    }
+  }
+  if (state.current) {
+    parts.push(state.current.trim());
+  }
+  return parts;
+}
+function applyFilterDirect(value, filterName, paramString, currentUrl) {
+  debugLog("Filters", "applyFilterDirect called with:", { value, filterName, paramString, currentUrl });
+  const filter = filters[filterName];
+  if (!filter) {
+    console.error(`Invalid filter: ${filterName}`);
+    debugLog("Filters", `Available filters:`, Object.keys(filters));
+    return typeof value === "string" ? value : JSON.stringify(value);
+  }
+  const stringInput = typeof value === "string" ? value : JSON.stringify(value);
+  let params = paramString ? [paramString] : [];
+  if (filterName === "markdown" && !paramString && currentUrl) {
+    params = [currentUrl];
+  }
+  if (filterName === "fragment_link" && currentUrl) {
+    params.push(currentUrl);
+  }
+  const output = filter(stringInput, params.join(":"));
+  debugLog("Filters", `Filter ${filterName} output:`, output);
+  if (typeof output === "string" && (output.startsWith("[") || output.startsWith("{"))) {
+    try {
+      const parsed = JSON.parse(output);
+      return JSON.stringify(parsed);
+    } catch {
+      return output;
+    }
+  }
+  return typeof output === "string" ? output : JSON.stringify(output);
+}
+function applyFilters(value, filterString, currentUrl) {
+  debugLog("Filters", "applyFilters called with:", { value, filterString, currentUrl });
+  if (!filterString) {
+    debugLog("Filters", "Empty filter string, returning original value");
+    return typeof value === "string" ? value : JSON.stringify(value);
+  }
+  let processedValue = value;
+  const filterNames = splitFilterString(filterString);
+  debugLog("Filters", "Split filter string:", filterNames);
+  const result = filterNames.reduce((result2, filterName) => {
+    const [name, ...params] = parseFilterString(filterName);
+    debugLog("Filters", `Parsed filter: ${name}, Params:`, params);
+    const filter = filters[name];
+    if (filter) {
+      const stringInput = typeof result2 === "string" ? result2 : JSON.stringify(result2);
+      if (name === "markdown" && params.length === 0 && currentUrl) {
+        params.push(currentUrl);
+      }
+      if (name === "fragment_link" && currentUrl) {
+        params.push(currentUrl);
+      }
+      const output = filter(stringInput, params.join(":"));
+      debugLog("Filters", `Filter ${name} output:`, output);
+      if (typeof output === "string" && (output.startsWith("[") || output.startsWith("{"))) {
+        try {
+          return JSON.parse(output);
+        } catch {
+          return output;
+        }
+      }
+      return output;
+    } else {
+      console.error(`Invalid filter: ${name}`);
+      debugLog("Filters", `Available filters:`, Object.keys(filters));
+      return result2;
+    }
+  }, processedValue);
+  return typeof result === "string" ? result : JSON.stringify(result);
+}
+
+// src/utils/parser.ts
+function parse(input) {
+  const tokenizerResult = tokenize(input);
+  const errors = tokenizerResult.errors.map((e) => ({
+    message: e.message,
+    line: e.line,
+    column: e.column
+  }));
+  const state = {
+    tokens: tokenizerResult.tokens,
+    pos: 0,
+    errors
+  };
+  const ast = parseTemplate(state);
+  return { ast, errors: state.errors };
+}
+function parseTemplate(state) {
+  const nodes = [];
+  while (!isAtEnd(state)) {
+    const node = parseNode(state);
+    if (node) {
+      nodes.push(node);
+    }
+  }
+  return nodes;
+}
+function parseNode(state) {
+  const token = peek(state);
+  switch (token.type) {
+    case "text":
+      return parseText(state);
+    case "variable_start":
+      return parseVariable(state);
+    case "tag_start":
+      return parseTag(state);
+    case "eof":
+      advance2(state);
+      return null;
+    default:
+      state.errors.push({
+        message: `Unexpected "${token.value}" in template`,
+        line: token.line,
+        column: token.column
+      });
+      advance2(state);
+      return null;
+  }
+}
+function parseText(state) {
+  const token = advance2(state);
+  return {
+    type: "text",
+    value: token.value,
+    line: token.line,
+    column: token.column
+  };
+}
+function parseVariable(state) {
+  const startToken = advance2(state);
+  const trimLeft = startToken.trimLeft || false;
+  const expression = parseExpression(state);
+  if (!expression) {
+    state.errors.push({
+      message: "Empty variable - add a variable name between {{ and }}",
+      line: startToken.line,
+      column: startToken.column
+    });
+    skipToEndOfVariable(state);
+    return null;
+  }
+  if (check(state, "identifier")) {
+    let extraWords = 0;
+    const savedPos = state.pos;
+    while (check(state, "identifier") && extraWords < 10) {
+      advance2(state);
+      extraWords++;
+    }
+    state.pos = savedPos;
+    if (extraWords > 0) {
+      state.errors.push({
+        message: 'Unknown variable. If this is a prompt, wrap it in quotes: {{"your prompt here"}}',
+        line: startToken.line,
+        column: startToken.column
+      });
+      skipToEndOfVariable(state);
+      return null;
+    }
+  }
+  let trimRight = false;
+  if (check(state, "variable_end")) {
+    const endToken = advance2(state);
+    trimRight = endToken.trimRight || false;
+  } else {
+    state.errors.push({
+      message: "Missing closing }}",
+      line: peek(state).line,
+      column: peek(state).column
+    });
+  }
+  return {
+    type: "variable",
+    expression,
+    trimLeft,
+    trimRight,
+    line: startToken.line,
+    column: startToken.column
+  };
+}
+function parseTag(state) {
+  const startToken = advance2(state);
+  const trimLeft = startToken.trimLeft || false;
+  const keywordToken = peek(state);
+  switch (keywordToken.type) {
+    case "keyword_if":
+      return parseIfStatement(state, startToken, trimLeft);
+    case "keyword_for":
+      return parseForStatement(state, startToken, trimLeft);
+    case "keyword_set":
+      return parseSetStatement(state, startToken, trimLeft);
+    case "keyword_else":
+    case "keyword_elseif":
+    case "keyword_endif":
+    case "keyword_endfor":
+      state.errors.push({
+        message: `Unexpected {% ${keywordToken.value} %} - no matching opening tag`,
+        line: keywordToken.line,
+        column: keywordToken.column
+      });
+      skipToEndOfTag(state);
+      return null;
+    default:
+      state.errors.push({
+        message: `Unknown tag: {% ${keywordToken.value} %}`,
+        line: keywordToken.line,
+        column: keywordToken.column
+      });
+      skipToEndOfTag(state);
+      return null;
+  }
+}
+function parseIfStatement(state, startToken, trimLeft) {
+  advance2(state);
+  const condition = parseExpression(state);
+  if (!condition) {
+    state.errors.push({
+      message: "{% if %} requires a condition",
+      line: startToken.line,
+      column: startToken.column
+    });
+    skipToEndOfTag(state);
+    return null;
+  }
+  let trimRight = false;
+  if (check(state, "tag_end")) {
+    trimRight = advance2(state).trimRight || false;
+  } else {
+    state.errors.push({
+      message: "Missing %} to close {% if %}",
+      line: peek(state).line,
+      column: peek(state).column
+    });
+  }
+  const consequent = parseBody(state, ["keyword_elseif", "keyword_else", "keyword_endif"]);
+  const elseifs = [];
+  while (checkTagKeyword(state, "keyword_elseif")) {
+    consumeTagStart(state);
+    advance2(state);
+    const elseifCondition = parseExpression(state);
+    if (!elseifCondition) {
+      state.errors.push({
+        message: "{% elseif %} requires a condition",
+        line: peek(state).line,
+        column: peek(state).column
+      });
+      skipToEndOfTag(state);
+      continue;
+    }
+    consumeTagEnd(state);
+    const elseifBody = parseBody(state, ["keyword_elseif", "keyword_else", "keyword_endif"]);
+    elseifs.push({ condition: elseifCondition, body: elseifBody });
+  }
+  let alternate = null;
+  if (checkTagKeyword(state, "keyword_else")) {
+    consumeTagStart(state);
+    advance2(state);
+    consumeTagEnd(state);
+    alternate = parseBody(state, ["keyword_endif"]);
+  }
+  if (checkTagKeyword(state, "keyword_endif")) {
+    consumeTagStart(state);
+    advance2(state);
+    consumeTagEnd(state);
+  } else {
+    state.errors.push({
+      message: "Missing {% endif %} to close {% if %}",
+      line: peek(state).line,
+      column: peek(state).column
+    });
+  }
+  return {
+    type: "if",
+    condition,
+    consequent,
+    elseifs,
+    alternate,
+    trimLeft,
+    trimRight,
+    line: startToken.line,
+    column: startToken.column
+  };
+}
+function parseForStatement(state, startToken, trimLeft) {
+  advance2(state);
+  if (!check(state, "identifier")) {
+    state.errors.push({
+      message: "{% for %} requires a variable name, e.g. {% for item in items %}",
+      line: peek(state).line,
+      column: peek(state).column
+    });
+    skipToEndOfTag(state);
+    return null;
+  }
+  const iterator = advance2(state).value;
+  if (!check(state, "keyword_in")) {
+    state.errors.push({
+      message: '{% for %} requires "in" keyword, e.g. {% for item in items %}',
+      line: peek(state).line,
+      column: peek(state).column
+    });
+    skipToEndOfTag(state);
+    return null;
+  }
+  advance2(state);
+  const iterable = parseExpression(state);
+  if (!iterable) {
+    state.errors.push({
+      message: '{% for %} requires something to loop over after "in"',
+      line: peek(state).line,
+      column: peek(state).column
+    });
+    skipToEndOfTag(state);
+    return null;
+  }
+  let trimRight = false;
+  if (check(state, "tag_end")) {
+    trimRight = advance2(state).trimRight || false;
+  } else {
+    state.errors.push({
+      message: "Missing %} to close {% for %}",
+      line: peek(state).line,
+      column: peek(state).column
+    });
+  }
+  const body = parseBody(state, ["keyword_endfor"]);
+  if (checkTagKeyword(state, "keyword_endfor")) {
+    consumeTagStart(state);
+    advance2(state);
+    consumeTagEnd(state);
+  } else {
+    state.errors.push({
+      message: "Missing {% endfor %} to close {% for %}",
+      line: peek(state).line,
+      column: peek(state).column
+    });
+  }
+  return {
+    type: "for",
+    iterator,
+    iterable,
+    body,
+    trimLeft,
+    trimRight,
+    line: startToken.line,
+    column: startToken.column
+  };
+}
+function parseSetStatement(state, startToken, trimLeft) {
+  advance2(state);
+  if (!check(state, "identifier")) {
+    state.errors.push({
+      message: "{% set %} requires a variable name, e.g. {% set name = value %}",
+      line: peek(state).line,
+      column: peek(state).column
+    });
+    skipToEndOfTag(state);
+    return null;
+  }
+  const variable = advance2(state).value;
+  if (!check(state, "op_assign")) {
+    state.errors.push({
+      message: '{% set %} requires "=" after variable name',
+      line: peek(state).line,
+      column: peek(state).column
+    });
+    skipToEndOfTag(state);
+    return null;
+  }
+  advance2(state);
+  const value = parseExpression(state);
+  if (!value) {
+    state.errors.push({
+      message: '{% set %} requires a value after "="',
+      line: peek(state).line,
+      column: peek(state).column
+    });
+    skipToEndOfTag(state);
+    return null;
+  }
+  let trimRight = false;
+  if (check(state, "tag_end")) {
+    trimRight = advance2(state).trimRight || false;
+  } else {
+    state.errors.push({
+      message: "Missing %} to close {% set %}",
+      line: peek(state).line,
+      column: peek(state).column
+    });
+  }
+  return {
+    type: "set",
+    variable,
+    value,
+    trimLeft,
+    trimRight,
+    line: startToken.line,
+    column: startToken.column
+  };
+}
+function parseBody(state, stopKeywords) {
+  const nodes = [];
+  while (!isAtEnd(state)) {
+    if (checkTagKeyword(state, ...stopKeywords)) {
+      break;
+    }
+    const node = parseNode(state);
+    if (node) {
+      nodes.push(node);
+    }
+  }
+  return nodes;
+}
+function parseExpression(state) {
+  return parseNullishExpression(state);
+}
+function parseNullishExpression(state) {
+  let left = parseFilterExpression(state);
+  if (!left) return null;
+  while (check(state, "op_nullish")) {
+    const opToken = advance2(state);
+    const right = parseFilterExpression(state);
+    if (!right) {
+      state.errors.push({
+        message: "Missing fallback value after ??",
+        line: opToken.line,
+        column: opToken.column
+      });
+      break;
+    }
+    left = {
+      type: "binary",
+      operator: "??",
+      left,
+      right,
+      line: opToken.line,
+      column: opToken.column
+    };
+  }
+  return left;
+}
+function parseFilterArgument(state) {
+  const startToken = peek(state);
+  if (check(state, "slash") || check(state, "star")) {
+    const token = advance2(state);
+    return {
+      type: "literal",
+      value: token.value,
+      raw: token.value,
+      line: token.line,
+      column: token.column
+    };
+  }
+  if (check(state, "lbracket")) {
+    let value2 = "";
+    let bracketDepth = 0;
+    const startLine = peek(state).line;
+    const startColumn = peek(state).column;
+    while (!isAtEnd(state)) {
+      const token = peek(state);
+      if (token.type === "lbracket") {
+        bracketDepth++;
+      } else if (token.type === "rbracket") {
+        bracketDepth--;
+        if (bracketDepth === 0) {
+          value2 += token.value;
+          advance2(state);
+          break;
+        }
+      }
+      if (bracketDepth === 0 && (token.type === "pipe" || token.type === "variable_end" || token.type === "comma")) {
+        break;
+      }
+      value2 += token.value;
+      advance2(state);
+    }
+    return {
+      type: "literal",
+      value: value2,
+      raw: value2,
+      line: startLine,
+      column: startColumn
+    };
+  }
+  if (check(state, "identifier")) {
+    const savedPos = state.pos;
+    const idToken = advance2(state);
+    if (check(state, "arrow")) {
+      let value2 = idToken.value + " ";
+      value2 += advance2(state).value + " ";
+      let braceDepth = 0;
+      let parenDepth = 0;
+      while (!isAtEnd(state)) {
+        const token = peek(state);
+        if (braceDepth === 0 && parenDepth === 0) {
+          if (token.type === "pipe" || token.type === "variable_end" || token.type === "tag_end") {
+            break;
+          }
+        }
+        if (token.type === "lbrace" || token.type === "lparen") {
+          if (token.type === "lbrace") braceDepth++;
+          else parenDepth++;
+        } else if (token.type === "rbrace" || token.type === "rparen") {
+          if (token.type === "rbrace") braceDepth--;
+          else parenDepth--;
+          if (braceDepth < 0 || parenDepth < 0) break;
+        }
+        if (token.type === "string") {
+          value2 += `"${token.value}"`;
+        } else {
+          value2 += token.value;
+        }
+        advance2(state);
+      }
+      return {
+        type: "literal",
+        value: value2.trim(),
+        raw: value2.trim(),
+        line: startToken.line,
+        column: startToken.column
+      };
+    }
+    state.pos = savedPos;
+  }
+  const first2 = parsePrimaryExpression(state);
+  if (!first2) return null;
+  if (first2.type === "literal" && startToken.type === "string") {
+    const formatString = (val) => `"${val}"`;
+    let combined = formatString(first2.value);
+    while (check(state, "colon")) {
+      const savedPos = state.pos;
+      advance2(state);
+      if (check(state, "string")) {
+        const next = parsePrimaryExpression(state);
+        if (next && next.type === "literal") {
+          combined += ":" + formatString(next.value);
+        }
+      } else {
+        state.pos = savedPos;
+        break;
+      }
+    }
+    return {
+      type: "literal",
+      value: combined,
+      raw: combined,
+      line: first2.line,
+      column: first2.column
+    };
+  }
+  if (first2.type === "literal" && startToken.type === "number" && check(state, "identifier")) {
+    const idToken = peek(state);
+    if (idToken.value.length === 1 && /^[a-z]$/i.test(idToken.value)) {
+      advance2(state);
+      const combined = String(first2.value) + idToken.value;
+      return {
+        type: "literal",
+        value: combined,
+        raw: combined,
+        line: first2.line,
+        column: first2.column
+      };
+    }
+  }
+  if (!check(state, "colon")) {
+    return first2;
+  }
+  let value = "";
+  if (first2.type === "literal") {
+    value = String(first2.value);
+  } else if (first2.type === "identifier") {
+    value = first2.name;
+  } else {
+    return first2;
+  }
+  while (check(state, "colon") && !isAtEnd(state)) {
+    advance2(state);
+    value += ":";
+    const next = parsePrimaryExpression(state);
+    if (next) {
+      if (next.type === "literal") {
+        value += String(next.value);
+      } else if (next.type === "identifier") {
+        value += next.name;
+      }
+    } else {
+      break;
+    }
+  }
+  return {
+    type: "literal",
+    value,
+    raw: value,
+    line: startToken.line,
+    column: startToken.column
+  };
+}
+function parseFilterExpression(state) {
+  let left = parseOrExpression(state);
+  if (!left) return null;
+  while (check(state, "pipe")) {
+    advance2(state);
+    if (!check(state, "identifier")) {
+      state.errors.push({
+        message: "Missing filter name after |",
+        line: peek(state).line,
+        column: peek(state).column
+      });
+      break;
+    }
+    const filterToken = advance2(state);
+    const args = [];
+    if (check(state, "colon")) {
+      advance2(state);
+      if (check(state, "lparen")) {
+        advance2(state);
+        while (!check(state, "rparen") && !isAtEnd(state)) {
+          const arg = parseOrExpression(state);
+          if (!arg) break;
+          if (arg.type === "literal" && typeof arg.value === "string" && check(state, "colon")) {
+            const formatStr = (val) => `"${val}"`;
+            let combined = formatStr(arg.value);
+            while (check(state, "colon")) {
+              advance2(state);
+              const next = parseOrExpression(state);
+              if (next && next.type === "literal" && typeof next.value === "string") {
+                combined += ":" + formatStr(next.value);
+              } else {
+                break;
+              }
+            }
+            args.push({
+              type: "literal",
+              value: combined,
+              raw: combined,
+              line: arg.line,
+              column: arg.column
+            });
+          } else {
+            args.push(arg);
+          }
+          if (check(state, "comma")) {
+            advance2(state);
+          } else {
+            break;
+          }
+        }
+        if (check(state, "rparen")) {
+          advance2(state);
+        }
+      } else {
+        const arg = parseFilterArgument(state);
+        if (arg) args.push(arg);
+        while (check(state, "comma")) {
+          advance2(state);
+          const nextArg = parseFilterArgument(state);
+          if (nextArg) args.push(nextArg);
+        }
+      }
+    }
+    left = {
+      type: "filter",
+      value: left,
+      name: filterToken.value,
+      args,
+      line: filterToken.line,
+      column: filterToken.column
+    };
+  }
+  return left;
+}
+function parseOrExpression(state) {
+  let left = parseAndExpression(state);
+  if (!left) return null;
+  while (check(state, "op_or")) {
+    const opToken = advance2(state);
+    const right = parseAndExpression(state);
+    if (!right) {
+      state.errors.push({
+        message: 'Missing value after "or"',
+        line: opToken.line,
+        column: opToken.column
+      });
+      break;
+    }
+    left = {
+      type: "binary",
+      operator: "or",
+      left,
+      right,
+      line: opToken.line,
+      column: opToken.column
+    };
+  }
+  return left;
+}
+function parseAndExpression(state) {
+  let left = parseNotExpression(state);
+  if (!left) return null;
+  while (check(state, "op_and")) {
+    const opToken = advance2(state);
+    const right = parseNotExpression(state);
+    if (!right) {
+      state.errors.push({
+        message: 'Missing value after "and"',
+        line: opToken.line,
+        column: opToken.column
+      });
+      break;
+    }
+    left = {
+      type: "binary",
+      operator: "and",
+      left,
+      right,
+      line: opToken.line,
+      column: opToken.column
+    };
+  }
+  return left;
+}
+function parseNotExpression(state) {
+  if (check(state, "op_not")) {
+    const opToken = advance2(state);
+    const argument = parseNotExpression(state);
+    if (!argument) {
+      state.errors.push({
+        message: 'Missing value after "not"',
+        line: opToken.line,
+        column: opToken.column
+      });
+      return null;
+    }
+    return {
+      type: "unary",
+      operator: "not",
+      argument,
+      line: opToken.line,
+      column: opToken.column
+    };
+  }
+  return parseComparisonExpression(state);
+}
+function parseComparisonExpression(state) {
+  let left = parsePostfixExpression(state);
+  if (!left) return null;
+  const comparisonOps = ["op_eq", "op_neq", "op_gt", "op_lt", "op_gte", "op_lte", "op_contains"];
+  if (comparisonOps.some((op) => check(state, op))) {
+    const opToken = advance2(state);
+    const right = parsePostfixExpression(state);
+    if (!right) {
+      state.errors.push({
+        message: `Missing value after "${opToken.value}"`,
+        line: opToken.line,
+        column: opToken.column
+      });
+      return left;
+    }
+    const operatorMap = {
+      "op_eq": "==",
+      "op_neq": "!=",
+      "op_gt": ">",
+      "op_lt": "<",
+      "op_gte": ">=",
+      "op_lte": "<=",
+      "op_contains": "contains"
+    };
+    return {
+      type: "binary",
+      operator: operatorMap[opToken.type] || opToken.value,
+      left,
+      right,
+      line: opToken.line,
+      column: opToken.column
+    };
+  }
+  return left;
+}
+function parsePostfixExpression(state) {
+  let left = parsePrimaryExpression(state);
+  if (!left) return null;
+  while (check(state, "lbracket")) {
+    const bracketToken = advance2(state);
+    const property = parseOrExpression(state);
+    if (!property) {
+      state.errors.push({
+        message: "Empty brackets [] - add an index or key",
+        line: bracketToken.line,
+        column: bracketToken.column
+      });
+      break;
+    }
+    if (check(state, "rbracket")) {
+      advance2(state);
+    } else {
+      state.errors.push({
+        message: "Missing closing ]",
+        line: peek(state).line,
+        column: peek(state).column
+      });
+    }
+    left = {
+      type: "member",
+      object: left,
+      property,
+      computed: true,
+      line: bracketToken.line,
+      column: bracketToken.column
+    };
+  }
+  return left;
+}
+function parsePrimaryExpression(state) {
+  const token = peek(state);
+  if (check(state, "lparen")) {
+    advance2(state);
+    const expr = parseOrExpression(state);
+    if (!expr) {
+      state.errors.push({
+        message: "Empty parentheses () - add an expression",
+        line: token.line,
+        column: token.column
+      });
+      return null;
+    }
+    if (check(state, "rparen")) {
+      advance2(state);
+    } else {
+      state.errors.push({
+        message: "Missing closing )",
+        line: peek(state).line,
+        column: peek(state).column
+      });
+    }
+    return {
+      type: "group",
+      expression: expr,
+      line: token.line,
+      column: token.column
+    };
+  }
+  if (check(state, "string")) {
+    const strToken = advance2(state);
+    return {
+      type: "literal",
+      value: strToken.value,
+      raw: strToken.value,
+      line: strToken.line,
+      column: strToken.column
+    };
+  }
+  if (check(state, "number")) {
+    const numToken = advance2(state);
+    return {
+      type: "literal",
+      value: parseFloat(numToken.value),
+      raw: numToken.value,
+      line: numToken.line,
+      column: numToken.column
+    };
+  }
+  if (check(state, "boolean")) {
+    const boolToken = advance2(state);
+    return {
+      type: "literal",
+      value: boolToken.value.toLowerCase() === "true",
+      raw: boolToken.value,
+      line: boolToken.line,
+      column: boolToken.column
+    };
+  }
+  if (check(state, "null")) {
+    const nullToken = advance2(state);
+    return {
+      type: "literal",
+      value: null,
+      raw: "null",
+      line: nullToken.line,
+      column: nullToken.column
+    };
+  }
+  if (check(state, "identifier")) {
+    const idToken = advance2(state);
+    let name = idToken.value;
+    if (check(state, "colon")) {
+      const colonToken = peek(state);
+      advance2(state);
+      let rest = "";
+      while (check(state, "identifier") || check(state, "dot") || check(state, "colon") || check(state, "lbracket") || check(state, "rbracket") || check(state, "number") || check(state, "string") || check(state, "star")) {
+        rest += advance2(state).value;
+      }
+      name = name + ":" + rest;
+    }
+    return {
+      type: "identifier",
+      name,
+      line: idToken.line,
+      column: idToken.column
+    };
+  }
+  return null;
+}
+function peek(state) {
+  return state.tokens[state.pos] || { type: "eof", value: "", line: 0, column: 0 };
+}
+function advance2(state) {
+  const token = peek(state);
+  if (!isAtEnd(state)) {
+    state.pos++;
+  }
+  return token;
+}
+function check(state, type) {
+  return peek(state).type === type;
+}
+function isAtEnd(state) {
+  return peek(state).type === "eof";
+}
+function checkTagKeyword(state, ...keywords) {
+  if (!check(state, "tag_start")) return false;
+  const nextPos = state.pos + 1;
+  if (nextPos >= state.tokens.length) return false;
+  const nextToken = state.tokens[nextPos];
+  return keywords.includes(nextToken.type);
+}
+function consumeTagStart(state) {
+  if (check(state, "tag_start")) {
+    return advance2(state);
+  }
+  return null;
+}
+function consumeTagEnd(state) {
+  if (check(state, "tag_end")) {
+    return advance2(state);
+  }
+  state.errors.push({
+    message: "Missing closing %}",
+    line: peek(state).line,
+    column: peek(state).column
+  });
+  return null;
+}
+function skipToEndOfTag(state) {
+  while (!isAtEnd(state) && !check(state, "tag_end")) {
+    advance2(state);
+  }
+  if (check(state, "tag_end")) {
+    advance2(state);
+  }
+}
+function skipToEndOfVariable(state) {
+  while (!isAtEnd(state) && !check(state, "variable_end")) {
+    advance2(state);
+  }
+  if (check(state, "variable_end")) {
+    advance2(state);
+  }
+}
+
+// src/utils/renderer.ts
+var defaultApplyFilterDirect = applyFilterDirect;
+async function render(template2, context, options = {}) {
+  const parseResult = parse(template2);
+  if (parseResult.errors.length > 0) {
+    return {
+      output: "",
+      errors: parseResult.errors.map((e) => ({
+        message: e.message,
+        line: e.line,
+        column: e.column
+      })),
+      hasDeferredVariables: false
+    };
+  }
+  return renderAST(parseResult.ast, context, options);
+}
+async function renderAST(ast, context, options = {}) {
+  const errors = [];
+  const state = {
+    context,
+    errors,
+    pendingTrimRight: false,
+    hasDeferredVariables: false
+  };
+  let output = "";
+  for (let i = 0; i < ast.length; i++) {
+    const node = ast[i];
+    const nodeOutput = await renderNode(node, state);
+    output = appendNodeOutput(output, nodeOutput, node, state);
+  }
+  if (options.trimOutput) {
+    output = output.trim();
+  }
+  return { output, errors, hasDeferredVariables: state.hasDeferredVariables };
+}
+async function renderNode(node, state) {
+  switch (node.type) {
+    case "text":
+      return renderText(node, state);
+    case "variable":
+      return renderVariable(node, state);
+    case "if":
+      return renderIf(node, state);
+    case "for":
+      return renderFor(node, state);
+    case "set":
+      return renderSet(node, state);
+    default:
+      state.errors.push({
+        message: `Unknown node type: ${node.type}`
+      });
+      return "";
+  }
+}
+function renderText(node, state) {
+  let text = node.value;
+  if (state.pendingTrimRight) {
+    text = trimLeadingWhitespace(text);
+    state.pendingTrimRight = false;
+  }
+  return text;
+}
+async function renderVariable(node, state) {
+  try {
+    const promptInfo = getPromptBase(node.expression);
+    if (promptInfo) {
+      if (node.trimRight) {
+        state.pendingTrimRight = true;
+      }
+      state.hasDeferredVariables = true;
+      return reconstructPromptTemplate(node.expression);
+    }
+    const value = await evaluateExpression2(node.expression, state);
+    const result = valueToString(value);
+    if (node.trimRight) {
+      state.pendingTrimRight = true;
+    }
+    return result;
+  } catch (error) {
+    state.errors.push({
+      message: `Error evaluating variable: ${error}`,
+      line: node.line,
+      column: node.column
+    });
+    return "";
+  }
+}
+function getPromptBase(expr) {
+  if (expr.type === "literal" && typeof expr.value === "string") {
+    return expr.value;
+  }
+  if (expr.type === "filter") {
+    return getPromptBase(expr.value);
+  }
+  return null;
+}
+function formatFilterArgs(args) {
+  const formatted = args.map((arg) => {
+    if (arg.type === "literal") {
+      const val = arg.value;
+      if (typeof val === "string") {
+        if (/^["'].*["']$/.test(val) || val.includes('":"') || val.includes("':'")) {
+          return val;
+        }
+        return `"${val}"`;
+      }
+      return String(val);
+    }
+    return String(arg.value || arg.name || "");
+  });
+  if (formatted.length > 1) {
+    return `(${formatted.join(",")})`;
+  }
+  return formatted[0] || "";
+}
+function reconstructPromptTemplate(expr) {
+  return `{{${reconstructPromptTemplateInner(expr)}}}`;
+}
+function reconstructPromptTemplateInner(expr) {
+  if (expr.type === "literal") {
+    const value = expr.value;
+    return typeof value === "string" ? `"${value}"` : String(value);
+  }
+  if (expr.type === "filter") {
+    const filter = expr;
+    const inner = reconstructPromptTemplateInner(filter.value);
+    let filterStr = `${inner}|${filter.name}`;
+    if (filter.args.length > 0) {
+      filterStr += `:${formatFilterArgs(filter.args)}`;
+    }
+    return filterStr;
+  }
+  return String(expr);
+}
+async function renderIf(node, state) {
+  try {
+    const conditionValue = await evaluateExpression2(node.condition, state);
+    if (isTruthy(conditionValue)) {
+      const result = await renderNodes(node.consequent, state);
+      if (node.trimRight) {
+        state.pendingTrimRight = true;
+      }
+      return result;
+    }
+    for (const elseif of node.elseifs) {
+      const elseifValue = await evaluateExpression2(elseif.condition, state);
+      if (isTruthy(elseifValue)) {
+        return renderNodes(elseif.body, state);
+      }
+    }
+    if (node.alternate) {
+      return renderNodes(node.alternate, state);
+    }
+    if (node.trimRight) {
+      state.pendingTrimRight = true;
+    }
+    return "";
+  } catch (error) {
+    state.errors.push({
+      message: `Error evaluating if condition: ${error}`,
+      line: node.line,
+      column: node.column
+    });
+    return "";
+  }
+}
+async function renderFor(node, state) {
+  try {
+    const iterableValue = await evaluateExpression2(node.iterable, state);
+    if (iterableValue === void 0 || iterableValue === null) {
+      if (node.trimRight) {
+        state.pendingTrimRight = true;
+      }
+      return "";
+    }
+    let iterableArray = iterableValue;
+    if (!Array.isArray(iterableArray) && typeof iterableArray === "string") {
+      try {
+        const parsed = JSON.parse(iterableArray);
+        if (Array.isArray(parsed)) {
+          iterableArray = parsed;
+        }
+      } catch {
+      }
+    }
+    if (!Array.isArray(iterableArray)) {
+      state.errors.push({
+        message: `For loop iterable is not an array: ${typeof iterableArray}`,
+        line: node.line,
+        column: node.column
+      });
+      if (node.trimRight) {
+        state.pendingTrimRight = true;
+      }
+      return "";
+    }
+    const results = [];
+    const length2 = iterableArray.length;
+    for (let i = 0; i < length2; i++) {
+      const item = iterableArray[i];
+      const loop = {
+        index: i + 1,
+        // 1-indexed
+        index0: i,
+        // 0-indexed
+        first: i === 0,
+        last: i === length2 - 1,
+        length: length2
+      };
+      const loopContext = {
+        ...state.context,
+        variables: {
+          ...state.context.variables,
+          [node.iterator]: item,
+          [`${node.iterator}_index`]: i,
+          // Keep for backwards compatibility
+          loop
+        }
+      };
+      const loopState = {
+        ...state,
+        context: loopContext
+      };
+      const itemResult = await renderNodes(node.body, loopState);
+      results.push(itemResult.trim());
+    }
+    if (node.trimRight) {
+      state.pendingTrimRight = true;
+    }
+    return results.join("\n");
+  } catch (error) {
+    state.errors.push({
+      message: `Error in for loop: ${error}`,
+      line: node.line,
+      column: node.column
+    });
+    return "";
+  }
+}
+async function renderSet(node, state) {
+  try {
+    const value = await evaluateExpression2(node.value, state);
+    state.context.variables[node.variable] = value;
+    if (node.trimRight) {
+      state.pendingTrimRight = true;
+    }
+    return "";
+  } catch (error) {
+    state.errors.push({
+      message: `Error in set: ${error}`,
+      line: node.line,
+      column: node.column
+    });
+    return "";
+  }
+}
+async function renderNodes(nodes, state) {
+  let output = "";
+  for (const node of nodes) {
+    const nodeOutput = await renderNode(node, state);
+    output = appendNodeOutput(output, nodeOutput, node, state);
+  }
+  return output;
+}
+function appendNodeOutput(output, nodeOutput, node, state) {
+  if ("trimLeft" in node && node.trimLeft && output.length > 0) {
+    output = trimTrailingWhitespace(output);
+  }
+  if (state.pendingTrimRight && nodeOutput.length > 0) {
+    output += trimLeadingWhitespace(nodeOutput);
+    state.pendingTrimRight = false;
+  } else {
+    output += nodeOutput;
+  }
+  return output;
+}
+async function evaluateExpression2(expr, state) {
+  switch (expr.type) {
+    case "literal":
+      return evaluateLiteral(expr);
+    case "identifier":
+      return evaluateIdentifier(expr, state);
+    case "binary":
+      return evaluateBinary(expr, state);
+    case "unary":
+      return evaluateUnary(expr, state);
+    case "filter":
+      return evaluateFilter(expr, state);
+    case "group":
+      return evaluateExpression2(expr.expression, state);
+    case "member":
+      return evaluateMember(expr, state);
+    default:
+      throw new Error(`Unknown expression type: ${expr.type}`);
+  }
+}
+function evaluateLiteral(expr) {
+  return expr.value;
+}
+async function evaluateIdentifier(expr, state) {
+  const name = expr.name;
+  if (name.startsWith("selector:") || name.startsWith("selectorHtml:")) {
+    if (state.context.asyncResolver) {
+      return state.context.asyncResolver(name, state.context);
+    }
+    state.hasDeferredVariables = true;
+    return `{{${name}}}`;
+  }
+  if (name.startsWith("schema:")) {
+    const value = resolveSchemaVariable(name, state.context.variables);
+    return value;
+  }
+  if (name.startsWith("prompt:") || name.startsWith('"')) {
+    state.hasDeferredVariables = true;
+    return `{{${name}}}`;
+  }
+  return resolveVariable(name, state.context.variables);
+}
+async function evaluateMember(expr, state) {
+  const object2 = await evaluateExpression2(expr.object, state);
+  const property = await evaluateExpression2(expr.property, state);
+  if (object2 === void 0 || object2 === null) {
+    return void 0;
+  }
+  if (Array.isArray(object2) && typeof property === "number") {
+    return object2[property];
+  }
+  if (Array.isArray(object2) && typeof property === "string" && /^\d+$/.test(property)) {
+    return object2[parseInt(property, 10)];
+  }
+  if (typeof object2 === "object" && property !== void 0) {
+    return object2[property];
+  }
+  return void 0;
+}
+async function evaluateBinary(expr, state) {
+  if (expr.operator === "??") {
+    const left2 = await evaluateExpression2(expr.left, state);
+    if (isTruthy(left2)) {
+      return left2;
+    }
+    return evaluateExpression2(expr.right, state);
+  }
+  const left = await evaluateExpression2(expr.left, state);
+  const right = await evaluateExpression2(expr.right, state);
+  switch (expr.operator) {
+    case "==":
+      return left == right;
+    case "!=":
+      return left != right;
+    case ">":
+      return left > right;
+    case "<":
+      return left < right;
+    case ">=":
+      return left >= right;
+    case "<=":
+      return left <= right;
+    case "contains":
+      return evaluateContains(left, right);
+    case "and":
+      return isTruthy(left) && isTruthy(right);
+    case "or":
+      return isTruthy(left) || isTruthy(right);
+    default:
+      throw new Error(`Unknown binary operator: ${expr.operator}`);
+  }
+}
+async function evaluateUnary(expr, state) {
+  const argument = await evaluateExpression2(expr.argument, state);
+  switch (expr.operator) {
+    case "not":
+      return !isTruthy(argument);
+    default:
+      throw new Error(`Unknown unary operator: ${expr.operator}`);
+  }
+}
+async function evaluateFilter(expr, state) {
+  const value = await evaluateExpression2(expr.value, state);
+  const args = [];
+  for (const arg of expr.args) {
+    let argValue = await evaluateExpression2(arg, state);
+    if (argValue === void 0 && arg.type === "identifier") {
+      argValue = arg.name;
+    }
+    args.push(argValue);
+  }
+  if (state.context.filters && state.context.filters[expr.name]) {
+    return state.context.filters[expr.name](value, ...args);
+  }
+  const stringValue = valueToString(value);
+  let paramString;
+  if (args.length > 0) {
+    const formattedArgs = args.map((a) => {
+      if (typeof a === "string") {
+        if (isQuotedString(a)) {
+          return a;
+        }
+        if (/\s*\w+\s*=>/.test(a)) {
+          return a;
+        }
+        if (/^[\w.:+\-*/]+$/.test(a)) {
+          return a;
+        }
+        return `"${a}"`;
+      }
+      return String(a);
+    });
+    paramString = formattedArgs.join(",");
+  }
+  const applyFilterDirectFn = state.context.applyFilterDirect || defaultApplyFilterDirect;
+  return applyFilterDirectFn(stringValue, expr.name, paramString, state.context.currentUrl);
+}
+function evaluateContains(left, right) {
+  if (left === void 0 || left === null) return false;
+  if (right === void 0 || right === null) return false;
+  if (Array.isArray(left)) {
+    return left.some((item) => {
+      if (typeof item === "string" && typeof right === "string") {
+        return item.toLowerCase() === right.toLowerCase();
+      }
+      return item == right;
+    });
+  }
+  if (typeof left === "string") {
+    const searchValue = typeof right === "string" ? right : String(right);
+    return left.toLowerCase().includes(searchValue.toLowerCase());
+  }
+  return false;
+}
+function resolveSchemaVariable(name, variables) {
+  const schemaKey = name.slice("schema:".length);
+  const nestedArrayMatch = schemaKey.match(/^(.*?)\[(\*|\d+)\](\.(.*))?$/);
+  if (nestedArrayMatch) {
+    const [, arrayKey, indexOrStar, , propertyPath] = nestedArrayMatch;
+    const arrayValue = resolveSchemaKey(arrayKey, variables);
+    if (arrayValue === void 0) return void 0;
+    const parsed = parseSchemaValue(arrayValue);
+    if (!Array.isArray(parsed)) return void 0;
+    if (indexOrStar === "*") {
+      if (propertyPath) {
+        return parsed.map((item) => getNestedValue(item, propertyPath)).filter((v) => v != null);
+      }
+      return parsed;
+    } else {
+      const index = parseInt(indexOrStar, 10);
+      const item = parsed[index];
+      if (item === void 0) return void 0;
+      return propertyPath ? getNestedValue(item, propertyPath) : item;
+    }
+  }
+  const rawValue = resolveSchemaKey(schemaKey, variables);
+  if (rawValue === void 0) return void 0;
+  return parseSchemaValue(rawValue);
+}
+function resolveSchemaKey(schemaKey, variables) {
+  const name = `schema:${schemaKey}`;
+  const exactValue = variables[`{{${name}}}`];
+  if (exactValue !== void 0) {
+    return exactValue;
+  }
+  if (variables[name] !== void 0) {
+    return variables[name];
+  }
+  if (!schemaKey.includes("@")) {
+    const matchingKey = Object.keys(variables).find(
+      (key) => key.includes("@") && key.endsWith(`:${schemaKey}}}`)
+    );
+    if (matchingKey) {
+      return variables[matchingKey];
+    }
+  }
+  return void 0;
+}
+function parseSchemaValue(value) {
+  if (typeof value === "string") {
+    if (value.startsWith("[") || value.startsWith("{")) {
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+    }
+  }
+  return value;
+}
+function resolveVariable(name, variables) {
+  const trimmed = name.trim();
+  const wrappedValue = variables[`{{${trimmed}}}`];
+  if (wrappedValue !== void 0) {
+    return wrappedValue;
+  }
+  if (variables[trimmed] !== void 0) {
+    return variables[trimmed];
+  }
+  if (trimmed.includes(".")) {
+    return getNestedValue(variables, trimmed);
+  }
+  return void 0;
+}
+function getNestedValue(obj, path) {
+  if (!path || !obj) return void 0;
+  const keys = path.split(".");
+  let value = obj;
+  for (const key of keys) {
+    if (value === void 0 || value === null) return void 0;
+    if (key.includes("[") && key.includes("]")) {
+      const match = key.match(/^([^\[]*)\[([^\]]+)\]/);
+      if (match) {
+        const [, arrayKey, indexStr] = match;
+        const baseValue = arrayKey ? value[arrayKey] : value;
+        if (Array.isArray(baseValue)) {
+          const index = parseInt(indexStr, 10);
+          value = baseValue[index];
+        } else if (baseValue && typeof baseValue === "object") {
+          value = baseValue[indexStr.replace(/^["']|["']$/g, "")];
+        } else {
+          return void 0;
+        }
+        continue;
+      }
+    }
+    if (value[`{{${key}}}`] !== void 0) {
+      value = value[`{{${key}}}`];
+    } else {
+      value = value[key];
+    }
+  }
+  return value;
+}
+function trimTrailingWhitespace(str) {
+  return str.replace(/[\t ]*\r?\n?$/, "");
+}
+function trimLeadingWhitespace(str) {
+  return str.replace(/^[\t ]*\r?\n?/, "");
+}
+function isQuotedString(str) {
+  return /^["'][\s\S]*["']$/.test(str) || str.includes('":"') || str.includes("':'");
+}
+function isTruthy(value) {
+  if (value === void 0 || value === null) return false;
+  if (value === "") return false;
+  if (value === 0) return false;
+  if (value === false) return false;
+  if (Array.isArray(value) && value.length === 0) return false;
+  return true;
+}
+function valueToString(value) {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  if (Array.isArray(value) && value.length === 1 && typeof value[0] !== "object") {
+    return String(value[0]);
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+
+// src/utils/shared.ts
+import dayjs4 from "dayjs";
+function buildVariables(params) {
+  const currentUrl = params.url.replace(/#:~:text=[^&]+(&|$)/, "");
+  const noteName = sanitizeFileName(params.title);
+  const timestamp = dayjs4().format("YYYY-MM-DDTHH:mm:ssZ");
+  const variables = {
+    "{{author}}": (params.author || "").trim(),
+    "{{content}}": (params.content || "").trim(),
+    "{{contentHtml}}": (params.contentHtml || "").trim(),
+    "{{selection}}": (params.selection || "").trim(),
+    "{{selectionHtml}}": (params.selectionHtml || "").trim(),
+    "{{date}}": timestamp,
+    "{{time}}": timestamp,
+    "{{description}}": (params.description || "").trim(),
+    "{{domain}}": getDomain(currentUrl),
+    "{{favicon}}": params.favicon || "",
+    "{{fullHtml}}": (params.fullHtml || "").trim(),
+    "{{highlights}}": params.highlights || "",
+    "{{image}}": params.image || "",
+    "{{noteName}}": noteName.trim(),
+    "{{published}}": (params.published || "").split(",")[0].trim(),
+    "{{site}}": (params.site || "").trim(),
+    "{{title}}": (params.title || "").trim(),
+    "{{url}}": currentUrl.trim(),
+    "{{language}}": (params.language || "").trim(),
+    "{{words}}": (params.wordCount ?? 0).toString()
+  };
+  if (params.extractedContent) {
+    for (const [key, value] of Object.entries(params.extractedContent)) {
+      variables[`{{${key}}}`] = value;
+    }
+  }
+  if (params.metaTags) {
+    for (const meta of params.metaTags) {
+      if (meta.name && meta.content) {
+        variables[`{{meta:name:${meta.name}}}`] = meta.content;
+      }
+      if (meta.property && meta.content) {
+        variables[`{{meta:property:${meta.property}}}`] = meta.content;
+      }
+    }
+  }
+  if (params.schemaOrgData) {
+    addSchemaOrgDataToVariables(params.schemaOrgData, variables);
+  }
+  return variables;
+}
+function addSchemaOrgDataToVariables(schemaData, variables, prefix = "") {
+  if (Array.isArray(schemaData)) {
+    schemaData.forEach((item, index) => {
+      if (!item || typeof item !== "object") return;
+      if (item["@type"]) {
+        if (Array.isArray(item["@type"])) {
+          item["@type"].forEach((type) => {
+            addSchemaOrgDataToVariables(item, variables, `@${type}:`);
+          });
+        } else {
+          addSchemaOrgDataToVariables(item, variables, `@${item["@type"]}:`);
+        }
+      } else {
+        addSchemaOrgDataToVariables(item, variables, `[${index}]:`);
+      }
+    });
+  } else if (typeof schemaData === "object" && schemaData !== null) {
+    const objectKey = `{{schema:${prefix.replace(/\.$/, "")}}}`;
+    variables[objectKey] = JSON.stringify(schemaData);
+    Object.entries(schemaData).forEach(([key, value]) => {
+      if (key === "@type") return;
+      const variableKey = `{{schema:${prefix}${key}}}`;
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        variables[variableKey] = String(value);
+      } else if (Array.isArray(value)) {
+        variables[variableKey] = JSON.stringify(value);
+        value.forEach((item, index) => {
+          addSchemaOrgDataToVariables(item, variables, `${prefix}${key}[${index}].`);
+        });
+      } else if (typeof value === "object" && value !== null) {
+        addSchemaOrgDataToVariables(value, variables, `${prefix}${key}.`);
+      }
+    });
+  }
+}
+function generateFrontmatter(properties, propertyTypes = {}) {
+  let frontmatter = "---\n";
+  for (const property of properties) {
+    const trimmedName = property.name.trim();
+    const needsQuotes = /[:\s\{\}\[\],&*#?|<>=!%@\\-]/.test(trimmedName) || /^\d/.test(trimmedName) || /^(true|false|null|yes|no|on|off)$/i.test(trimmedName);
+    const propertyKey = needsQuotes ? property.name.includes('"') ? `'${property.name.replace(/'/g, "''")}'` : `"${property.name}"` : property.name;
+    frontmatter += `${propertyKey}:`;
+    const propertyType = propertyTypes[property.name] || "text";
+    switch (propertyType) {
+      case "multitext": {
+        let items;
+        if (property.value.trim().startsWith('["') && property.value.trim().endsWith('"]')) {
+          try {
+            items = JSON.parse(property.value);
+          } catch {
+            items = property.value.split(",").map((item) => item.trim());
+          }
+        } else {
+          items = property.value.split(/,(?![^\[]*\]\])/).map((item) => item.trim());
+        }
+        items = items.filter((item) => item !== "");
+        if (items.length > 0) {
+          frontmatter += "\n";
+          items.forEach((item) => {
+            frontmatter += `  - "${escapeDoubleQuotes(item)}"
+`;
+          });
+        } else {
+          frontmatter += "\n";
+        }
+        break;
+      }
+      case "number": {
+        const numericValue = property.value.replace(/[^\d.-]/g, "");
+        frontmatter += numericValue ? ` ${parseFloat(numericValue)}
+` : "\n";
+        break;
+      }
+      case "checkbox": {
+        const isChecked = typeof property.value === "boolean" ? property.value : property.value === "true";
+        frontmatter += ` ${isChecked}
+`;
+        break;
+      }
+      case "date":
+      case "datetime":
+        frontmatter += property.value.trim() !== "" ? ` ${property.value}
+` : "\n";
+        break;
+      default:
+        frontmatter += property.value.trim() !== "" ? ` "${escapeDoubleQuotes(property.value)}"
+` : "\n";
+    }
+  }
+  frontmatter += "---\n";
+  if (frontmatter.trim() === "---\n---") {
+    return "";
+  }
+  return frontmatter;
+}
+function formatPropertyValue(value, type, templateValue) {
+  switch (type) {
+    case "number": {
+      const numericValue = value.replace(/[^\d.-]/g, "");
+      return numericValue ? parseFloat(numericValue).toString() : value;
+    }
+    case "checkbox":
+      return (value.toLowerCase() === "true" || value === "1").toString();
+    case "date":
+    case "datetime": {
+      if (!templateValue.includes("|date:")) {
+        const d = dayjs4(value);
+        if (d.isValid()) {
+          return d.format(type === "date" ? "YYYY-MM-DD" : "YYYY-MM-DDTHH:mm:ssZ");
+        }
+      }
+      return value;
+    }
+    default:
+      return value;
+  }
+}
+function extractContentBySelector(doc, selector, attribute, extractHtml = false) {
+  try {
+    const elements = doc.querySelectorAll(selector);
+    if (elements.length === 0) {
+      return "";
+    }
+    return Array.from(elements).map((el) => {
+      if (attribute) {
+        return el.getAttribute(attribute) || "";
+      }
+      return extractHtml ? el.outerHTML : el.textContent?.trim() || "";
+    });
+  } catch (error) {
+    console.error("Error in extractContentBySelector:", error);
+    return "";
+  }
+}
+function selectorContentToString(content) {
+  if (Array.isArray(content)) {
+    return content.length === 1 ? String(content[0]) : JSON.stringify(content);
+  }
+  return content;
+}
+
+// src/utils/variables/selector.ts
+async function sendExtractContent(tabId, selector, attribute, extractHtml) {
+  const response = await browser_polyfill_default.runtime.sendMessage({
+    action: "sendMessageToTab",
+    tabId,
+    message: {
+      action: "extractContent",
+      selector,
+      attribute,
+      extractHtml
+    }
+  });
+  return response || void 0;
+}
+async function resolveSelector(tabId, selectorExpr) {
+  const selectorRegex = /^(selector|selectorHtml):(.*?)(?:\?(.*))?$/;
+  const matches = selectorExpr.match(selectorRegex);
+  if (!matches) {
+    console.error("Invalid selector format:", selectorExpr);
+    return void 0;
+  }
+  const [, selectorType, rawSelector, attribute] = matches;
+  const extractHtml = selectorType === "selectorHtml";
+  const selector = rawSelector.replace(/\\"/g, '"').replace(/\s+/g, " ").trim();
+  try {
+    const response = await sendExtractContent(tabId, selector, attribute, extractHtml);
+    return response ? response.content : void 0;
+  } catch (error) {
+    console.error("Error extracting content by selector:", error, { selector, attribute, extractHtml });
+    return void 0;
+  }
+}
+async function processSelector(tabId, match, currentUrl) {
+  const selectorRegex = /{{(selector|selectorHtml):(.*?)(?:\?(.*?))?(?:\|(.*?))?}}/;
+  const matches = match.match(selectorRegex);
+  if (!matches) {
+    console.error("Invalid selector format:", match);
+    return match;
+  }
+  const [, selectorType, rawSelector, attribute, filtersString] = matches;
+  const extractHtml = selectorType === "selectorHtml";
+  const selector = rawSelector.replace(/\\"/g, '"').replace(/\s+/g, " ").trim();
+  try {
+    const response = await sendExtractContent(tabId, selector, attribute, extractHtml);
+    let content = response ? response.content : "";
+    const contentString = selectorContentToString(content);
+    debugLog("ContentExtractor", "Applying filters:", { selector, filterString: filtersString });
+    const filteredContent = applyFilters(contentString, filtersString, currentUrl);
+    return filteredContent;
+  } catch (error) {
+    console.error("Error extracting content by selector:", error, { selector, attribute, extractHtml });
+    return "";
+  }
+}
+
+// src/utils/resolver.ts
+function resolveVariable2(name, variables) {
+  const trimmed = name.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1).replace(/\\(.)/g, "$1");
+  }
+  if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+    return parseFloat(trimmed);
+  }
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  if (trimmed === "null") return null;
+  if (trimmed === "undefined") return void 0;
+  if (trimmed.startsWith("schema:")) {
+    return resolveSchemaVariable2(trimmed, variables);
+  }
+  if (!trimmed.includes(".") && !trimmed.includes("[")) {
+    const wrappedValue = variables[`{{${trimmed}}}`];
+    if (wrappedValue !== void 0) {
+      return wrappedValue;
+    }
+    if (variables[trimmed] !== void 0) {
+      return variables[trimmed];
+    }
+  }
+  return getNestedValue2(variables, trimmed);
+}
+function resolveSchemaVariable2(schemaKey, variables) {
+  let value = variables[`{{${schemaKey}}}`];
+  if (value !== void 0) {
+    return value;
+  }
+  const shortKey = schemaKey.replace("schema:", "");
+  if (!shortKey.includes("@")) {
+    const matchingKey = Object.keys(variables).find((key) => key.includes("@") && key.endsWith(`:${shortKey}}}`));
+    if (matchingKey) {
+      return variables[matchingKey];
+    }
+  }
+  return void 0;
+}
+function getNestedValue2(obj, path) {
+  if (!path || !obj) return void 0;
+  const keys = path.split(".");
+  return keys.reduce((value, key) => {
+    if (value === void 0 || value === null) return void 0;
+    if (key.includes("[") && key.includes("]")) {
+      const match = key.match(/^([^\[]*)\[([^\]]+)\]/);
+      if (match) {
+        const [, arrayKey, indexStr] = match;
+        const baseValue = arrayKey ? value[arrayKey] : value;
+        if (Array.isArray(baseValue)) {
+          const index = parseInt(indexStr, 10);
+          return baseValue[index];
+        }
+        if (baseValue && typeof baseValue === "object") {
+          return baseValue[indexStr.replace(/^["']|["']$/g, "")];
+        }
+        return void 0;
+      }
+    }
+    return value[key];
+  }, obj);
+}
+function valueToString2(value) {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+
+// src/utils/variables/simple.ts
+async function processSimpleVariable(variableString, variables, currentUrl) {
+  const [variablePath, ...filterParts] = variableString.split("|").map((part) => part.trim());
+  const value = resolveVariable2(variablePath, variables);
+  const stringValue = valueToString2(value);
+  const filtersString = filterParts.join("|");
+  return applyFilters(stringValue, filtersString, currentUrl);
+}
+
+// src/utils/variables/schema.ts
+function splitListString(str) {
+  return str.split(/(?=\d+\.|[-*•]\s)/).map(
+    (item) => item.replace(/^(?:\d+\.|[-*•])\s*/, "").trim()
+  ).filter((item) => item.length > 0);
+}
+async function processSchema(match, variables, currentUrl) {
+  const [, fullSchemaKey] = match.match(/{{schema:(.*?)}}/) || [];
+  if (!fullSchemaKey) {
+    return "";
+  }
+  const [schemaKey, ...filterParts] = fullSchemaKey.split("|");
+  const filtersString = filterParts.join("|");
+  let schemaValue = "";
+  const nestedArrayMatch = schemaKey.match(/(.*?)\[(\*|\d+)\](.*)/);
+  if (nestedArrayMatch) {
+    const [, arrayKey, indexOrStar, propertyKey] = nestedArrayMatch;
+    let fullArrayKey = arrayKey;
+    if (!arrayKey.includes("@")) {
+      const matchingKey = Object.keys(variables).find((key) => key.includes("@") && key.endsWith(`:${arrayKey}}}`));
+      if (matchingKey) {
+        fullArrayKey = matchingKey.replace("{{schema:", "").replace("}}", "");
+      }
+    }
+    try {
+      const rawValue = variables[`{{schema:${fullArrayKey}}}`] || "[]";
+      if (rawValue.trim().match(/^(?:\d+\.|[-*•]\s)/m)) {
+        const list2 = splitListString(rawValue);
+        if (indexOrStar === "*") {
+          schemaValue = JSON.stringify(list2);
+        } else {
+          const index = parseInt(indexOrStar, 10);
+          schemaValue = list2[index] || "";
+        }
+      } else {
+        const arrayValue = JSON.parse(rawValue);
+        if (Array.isArray(arrayValue)) {
+          if (indexOrStar === "*") {
+            schemaValue = JSON.stringify(arrayValue.map((item) => getNestedProperty3(item, propertyKey.slice(1))).filter(Boolean));
+          } else {
+            const index = parseInt(indexOrStar, 10);
+            schemaValue = arrayValue[index] ? getNestedProperty3(arrayValue[index], propertyKey.slice(1)) : "";
+          }
+        }
+      }
+    } catch (error) {
+      console.error("Error processing schema array:", error);
+      console.error("Raw value:", variables[`{{schema:${fullArrayKey}}}`]);
+      return "";
+    }
+  } else {
+    if (!schemaKey.includes("@")) {
+      const matchingKey = Object.keys(variables).find((key) => key.includes("@") && key.endsWith(`:${schemaKey}}}`));
+      if (matchingKey) {
+        schemaValue = variables[matchingKey];
+      }
+    }
+    if (!schemaValue) {
+      schemaValue = variables[`{{schema:${schemaKey}}}`] || "";
+    }
+  }
+  return applyFilters(schemaValue, filtersString, currentUrl);
+}
+function getNestedProperty3(obj, path) {
+  return path.split(".").reduce((prev, curr) => prev && prev[curr], obj);
+}
+
+// src/utils/storage-utils.ts
+var generalSettings2 = {
+  vaults: [],
+  betaFeatures: false,
+  legacyMode: false,
+  silentOpen: false,
+  openBehavior: "popup",
+  highlighterEnabled: true,
+  alwaysShowHighlights: false,
+  highlightBehavior: "highlight-inline",
+  showMoreActionsButton: false,
+  interpreterModel: "",
+  models: [],
+  providers: [],
+  interpreterEnabled: false,
+  interpreterAutoRun: false,
+  defaultPromptContext: "",
+  propertyTypes: [],
+  readerSettings: {
+    fontSize: 16,
+    lineHeight: 1.6,
+    maxWidth: 38,
+    lightTheme: "default",
+    darkTheme: "same",
+    appearance: "auto",
+    fonts: [],
+    defaultFont: "",
+    blendImages: true,
+    colorLinks: false,
+    followLinks: true,
+    pinPlayer: true,
+    autoScroll: true,
+    highlightActiveLine: true,
+    customCss: ""
+  },
+  stats: {
+    addToObsidian: 0,
+    saveFile: 0,
+    copyToClipboard: 0,
+    share: 0
+  },
+  history: [],
+  ratings: [],
+  saveBehavior: "addToObsidian"
+};
+if (typeof window !== "undefined") {
+  window.debugStorage = (key) => {
+    if (key) {
+      return browser_polyfill_default.storage.sync.get(key).then((data) => {
+        console.log(`Sync storage contents for key "${key}":`, data);
+        return data;
+      });
+    }
+    return browser_polyfill_default.storage.sync.get(null).then((data) => {
+      console.log("Sync storage contents:", data);
+      return data;
+    });
+  };
+}
+
+// src/utils/variables/prompt.ts
+async function processPrompt(match, variables, currentUrl) {
+  if (generalSettings2.interpreterEnabled) {
+    const promptRegex = /{{(?:prompt:)?"(.*?)"(\|.*?)?}}/;
+    const matches = match.match(promptRegex);
+    if (!matches) {
+      console.error("Invalid prompt format:", match);
+      return match;
+    }
+    const [, promptText, filters2 = ""] = matches;
+    return match;
+  } else {
+    return "";
+  }
+}
+
+// src/utils/template-compiler.ts
+async function compileTemplate(tabId, text, variables, currentUrl, customAsyncResolver, customSelectorProcessor) {
+  currentUrl = currentUrl.replace(/#:~:text=[^&]+(&|$)/, "");
+  const asyncResolver = customAsyncResolver ?? (async (name, ctx) => {
+    if (name.startsWith("selector:") || name.startsWith("selectorHtml:")) {
+      return resolveSelector(ctx.tabId, name);
+    }
+    return void 0;
+  });
+  const context = {
+    variables,
+    currentUrl,
+    tabId,
+    applyFilterDirect,
+    asyncResolver
+  };
+  const result = await render(text, context);
+  if (result.errors.length > 0) {
+    console.error("Template compilation errors:", result.errors.map((e) => `Line ${e.line}: ${e.message}`).join("; "));
+  }
+  if (!result.hasDeferredVariables) {
+    return result.output;
+  }
+  const processedText = await processVariables(tabId, result.output, variables, currentUrl, customSelectorProcessor);
+  return processedText;
+}
+async function processVariables(tabId, text, variables, currentUrl, customSelectorProcessor) {
+  const regex = /{{([\s\S]*?)}}/g;
+  let result = text;
+  let match;
+  while ((match = regex.exec(result)) !== null) {
+    const fullMatch = match[0];
+    const trimmedMatch = match[1].trim();
+    let replacement;
+    if (trimmedMatch.startsWith("selector:") || trimmedMatch.startsWith("selectorHtml:")) {
+      if (customSelectorProcessor) {
+        replacement = await customSelectorProcessor(fullMatch, currentUrl);
+      } else {
+        replacement = await processSelector(tabId, fullMatch, currentUrl);
+      }
+    } else if (trimmedMatch.startsWith("schema:")) {
+      replacement = await processSchema(fullMatch, variables, currentUrl);
+    } else if (trimmedMatch.startsWith('"') || trimmedMatch.startsWith("prompt:")) {
+      replacement = await processPrompt(fullMatch, variables, currentUrl);
+    } else {
+      replacement = await processSimpleVariable(trimmedMatch, variables, currentUrl);
+    }
+    result = result.substring(0, match.index) + replacement + result.substring(match.index + fullMatch.length);
+    regex.lastIndex = match.index + replacement.length;
+  }
+  return result;
+}
+
+// src/api.ts
+function createAsyncResolver(doc) {
+  return async (name, _context) => {
+    if (name.startsWith("selector:") || name.startsWith("selectorHtml:")) {
+      const extractHtml = name.startsWith("selectorHtml:");
+      const prefix = extractHtml ? "selectorHtml:" : "selector:";
+      const selectorPart = name.slice(prefix.length);
+      const attrMatch = selectorPart.match(/^(.+?)\?(.+)$/);
+      const selector = attrMatch ? attrMatch[1] : selectorPart;
+      const attribute = attrMatch ? attrMatch[2] : void 0;
+      return extractContentBySelector(
+        doc,
+        selector.replace(/\\"/g, '"'),
+        attribute,
+        extractHtml
+      );
+    }
+    return void 0;
+  };
+}
+function createSelectorProcessor(doc) {
+  return async (match, currentUrl) => {
+    const selectorRegex = /{{(selector|selectorHtml):(.*?)(?:\?(.*?))?(?:\|(.*?))?}}/;
+    const matches = match.match(selectorRegex);
+    if (!matches) return match;
+    const [, selectorType, rawSelector, attribute, filtersString] = matches;
+    const extractHtml = selectorType === "selectorHtml";
+    const selector = rawSelector.replace(/\\"/g, '"').replace(/\s+/g, " ").trim();
+    const content = extractContentBySelector(doc, selector, attribute, extractHtml);
+    const contentString = selectorContentToString(content);
+    return filtersString ? applyFilters(contentString, filtersString, currentUrl) : contentString;
+  };
+}
+function matchTriggerPattern(pattern, url) {
+  if (pattern.startsWith("/") && pattern.endsWith("/")) {
+    try {
+      return new RegExp(pattern.slice(1, -1)).test(url);
+    } catch {
+      return false;
+    }
+  }
+  return url.startsWith(pattern);
+}
+function matchSchemaPattern(pattern, schemaOrgData) {
+  const match = pattern.match(/^schema:(@\w+)?(?:\.(.+?))?(?:=(.+))?$/);
+  if (!match) return false;
+  const [, schemaType, schemaKey, expectedValue] = match;
+  if (!schemaType && !schemaKey) return false;
+  const schemaArray = Array.isArray(schemaOrgData) ? schemaOrgData : [schemaOrgData];
+  const flattened = schemaArray.flatMap((s) => Array.isArray(s) ? s : [s]);
+  for (const schema of flattened) {
+    if (!schema || typeof schema !== "object") continue;
+    if (schemaType) {
+      const types = Array.isArray(schema["@type"]) ? schema["@type"] : [schema["@type"]];
+      if (!types.includes(schemaType.slice(1))) continue;
+    }
+    if (schemaKey) {
+      const keys = schemaKey.split(".");
+      let val = schema;
+      for (const k of keys) {
+        val = val && typeof val === "object" && k in val ? val[k] : void 0;
+      }
+      if (expectedValue) {
+        if (Array.isArray(val) ? val.includes(expectedValue) : val === expectedValue) return true;
+      } else if (val !== void 0) {
+        return true;
+      }
+    } else {
+      return true;
+    }
+  }
+  return false;
+}
+function matchTemplate(templates, url, schemaOrgData) {
+  for (const template2 of templates) {
+    if (!template2.triggers) continue;
+    for (const trigger of template2.triggers) {
+      if (!trigger.startsWith("schema:") && matchTriggerPattern(trigger, url)) {
+        return template2;
+      }
+    }
+  }
+  if (schemaOrgData) {
+    for (const template2 of templates) {
+      if (!template2.triggers) continue;
+      for (const trigger of template2.triggers) {
+        if (trigger.startsWith("schema:") && matchSchemaPattern(trigger, schemaOrgData)) {
+          return template2;
+        }
+      }
+    }
+  }
+  return void 0;
+}
+async function clip(options) {
+  const { html, url, template: template2, documentParser, propertyTypes, parsedDocument } = options;
+  const doc = parsedDocument ?? documentParser.parseFromString(html, "text/html");
+  const defuddle = new DefuddleClass(doc, { url });
+  const defuddleResult = defuddle.parse();
+  const markdownContent = createMarkdownContent2(defuddleResult.content, url);
+  const variables = buildVariables({
+    title: defuddleResult.title,
+    author: defuddleResult.author,
+    content: markdownContent,
+    contentHtml: defuddleResult.content,
+    url,
+    fullHtml: html,
+    description: defuddleResult.description,
+    favicon: defuddleResult.favicon,
+    image: defuddleResult.image,
+    published: defuddleResult.published,
+    site: defuddleResult.site,
+    language: defuddleResult.language,
+    wordCount: defuddleResult.wordCount,
+    schemaOrgData: defuddleResult.schemaOrgData,
+    metaTags: defuddleResult.metaTags,
+    extractedContent: defuddleResult.variables
+  });
+  const asyncResolver = createAsyncResolver(doc);
+  const selectorProcessor = createSelectorProcessor(doc);
+  const compile = (text) => compileTemplate(0, text, variables, url, asyncResolver, selectorProcessor);
+  const compiledNoteName = await compile(template2.noteNameFormat);
+  const noteName = sanitizeFileName(compiledNoteName) || "Untitled";
+  const compiledProperties = await Promise.all(
+    template2.properties.map(async (prop) => {
+      let value = await compile(prop.value);
+      const propType = prop.type || "text";
+      value = formatPropertyValue(value, propType, prop.value);
+      return { name: prop.name, value, type: prop.type };
+    })
+  );
+  const typeMap = {};
+  for (const prop of template2.properties) {
+    if (prop.type) {
+      typeMap[prop.name] = prop.type;
+    }
+  }
+  if (propertyTypes) {
+    Object.assign(typeMap, propertyTypes);
+  }
+  const frontmatter = generateFrontmatter(compiledProperties, typeMap);
+  const content = await compile(template2.noteContentFormat);
+  const fullContent = frontmatter ? frontmatter + content : content;
+  return {
+    noteName,
+    frontmatter,
+    content,
+    fullContent,
+    properties: compiledProperties,
+    variables
+  };
+}
+export {
+  clip,
+  createAsyncResolver,
+  createSelectorProcessor,
+  matchTemplate
+};