@pixerate/editor 0.23.0 → 0.24.0

package/dist/chunk-MKA3AHLV.cjs

@@ -0,0 +1,256 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/grammar/tokens.ts
+var TEMPLATE_REGEX = /{{\s*([^}]+?)\s*}}/g;
+var VARIABLE_REGEX = /(?<!\{)\{(?!\})((?:\\[\s\S]|[^{}\\])*\\?)\}(?!\})/g;
+var INSTRUCTION_REGEX = /__(.+?)__/g;
+var templateRegex = TEMPLATE_REGEX;
+var variableRegex = VARIABLE_REGEX;
+var instructionRegex = INSTRUCTION_REGEX;
+
+// src/grammar/variables.ts
+var CONDITIONAL_PREFIXES = {
+  "?": "if",
+  "!": "unless",
+  "/": "end"
+};
+function unescapeVariableText(text) {
+  return text.replace(/\\([\\{}|])/g, "$1");
+}
+function escapeVariableText(text) {
+  return text.replace(/[\\{}|]/g, (ch) => `\\${ch}`);
+}
+function splitUnescapedPipes(body, limit) {
+  const parts = [];
+  let current = "";
+  for (let i = 0; i < body.length; i++) {
+    const ch = body[i];
+    if (ch === "\\" && i + 1 < body.length) {
+      current += ch + body[i + 1];
+      i++;
+      continue;
+    }
+    if (ch === "|" && parts.length < limit - 1) {
+      parts.push(current);
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  parts.push(current);
+  return parts;
+}
+function parseVariableBody(inner) {
+  const prefix = CONDITIONAL_PREFIXES[inner[0]];
+  if (prefix) {
+    const name = inner.slice(1).trim();
+    if (name && !/[|\\]/.test(name)) {
+      return { kind: "conditional", conditional: prefix, name };
+    }
+  }
+  const [rawName, rawDefault, rawDescription] = splitUnescapedPipes(inner, 3);
+  const parsed = {
+    kind: "variable",
+    name: unescapeVariableText(rawName.trim())
+  };
+  if (rawDefault !== void 0) {
+    parsed.defaultValue = unescapeVariableText(rawDefault.trim());
+  }
+  if (rawDescription !== void 0) {
+    parsed.description = unescapeVariableText(rawDescription.trim());
+  }
+  return parsed;
+}
+function isPromptValueSet(value) {
+  if (value === null || value === void 0 || value === false) return false;
+  return String(value).trim() !== "";
+}
+function getSuppliedValue(values, name) {
+  if (!Object.prototype.hasOwnProperty.call(values, name)) return void 0;
+  const value = values[name];
+  if (value === null || value === void 0) return void 0;
+  return String(value);
+}
+function evaluateCondition(conditional, name, values, comparison) {
+  const holds = comparison ? compareConditionValues(
+    _nullishCoalesce(getSuppliedValue(values, name), () => ( "")),
+    comparison.operator,
+    comparison.operand
+  ) : isPromptValueSet(values[name]);
+  return conditional === "if" ? holds : !holds;
+}
+var NUMBER_PATTERN = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i;
+function parseComparableNumber(text) {
+  const trimmed = text.trim();
+  if (!NUMBER_PATTERN.test(trimmed)) return void 0;
+  const value = Number(trimmed);
+  return Number.isFinite(value) ? value : void 0;
+}
+function compareConditionValues(left, operator, right) {
+  const a = parseComparableNumber(left);
+  const b = parseComparableNumber(right);
+  let order;
+  if (a !== void 0 && b !== void 0) {
+    order = a === b ? 0 : a < b ? -1 : 1;
+  } else {
+    const x = left.toLowerCase();
+    const y = right.toLowerCase();
+    order = x === y ? 0 : x < y ? -1 : 1;
+  }
+  switch (operator) {
+    case "=":
+      return order === 0;
+    case "<>":
+      return order !== 0;
+    case "<":
+      return order < 0;
+    case ">":
+      return order > 0;
+    case "<=":
+      return order <= 0;
+    case ">=":
+      return order >= 0;
+    default:
+      return false;
+  }
+}
+var COMPARISON_PATTERN = /^([^=<>!]+?)\s*(<>|<=|>=|!=|=|<|>)\s*([\s\S]*)$/;
+function conditionSubject(name) {
+  const match = COMPARISON_PATTERN.exec(name.trim());
+  if (!match) return void 0;
+  return match[1].trim() || void 0;
+}
+function parseComparison(text) {
+  const match = COMPARISON_PATTERN.exec(text.trim());
+  if (!match) return void 0;
+  const subject = match[1].trim();
+  if (!subject) return void 0;
+  const written = match[2];
+  const operator = written === "!=" ? "<>" : written;
+  const rest = match[3];
+  if (rest === "") {
+    return {
+      subject,
+      error: `Missing value after "${written}" (write "" to compare with an empty value)`
+    };
+  }
+  if (rest.startsWith('"')) {
+    if (rest.length < 2 || !rest.endsWith('"')) {
+      return { subject, error: `Unterminated quote in ${rest}` };
+    }
+    return { subject, comparison: { operator, operand: rest.slice(1, -1) } };
+  }
+  if (/^[=<>!]/.test(rest)) {
+    return {
+      subject,
+      error: `Unexpected "${rest[0]}" after "${written}"; operators are = <> < > <= >=`
+    };
+  }
+  return { subject, comparison: { operator, operand: rest } };
+}
+function formatComparisonOperand(operand) {
+  return operand === "" || operand !== operand.trim() || /^[=<>!"]/.test(operand) ? `"${operand}"` : operand;
+}
+function formatConditionalTag(tag) {
+  const prefix = tag.conditional === "unless" ? "!" : tag.conditional === "end" ? "/" : "?";
+  const comparison = tag.comparison ? `${tag.comparison.operator}${formatComparisonOperand(tag.comparison.operand)}` : "";
+  return `{${prefix}${tag.value}${comparison}}`;
+}
+function describeConditionalTag(tag) {
+  if (tag.conditional === "end") return `End of section: ${tag.value}`;
+  const shown = tag.conditional === "unless" ? "Hidden" : "Shown";
+  if (tag.comparison) {
+    return `${shown} when "${tag.value}" ${tag.comparison.operator} ${formatComparisonOperand(tag.comparison.operand)}`;
+  }
+  return tag.conditional === "unless" ? `Shown when "${tag.value}" is empty` : `Shown when "${tag.value}" has a value`;
+}
+function parseConditionExpression(text) {
+  let body = text.trim();
+  let negated = false;
+  if (body.startsWith("!")) {
+    negated = true;
+    body = body.slice(1).trim();
+  } else if (body.startsWith("?")) {
+    body = body.slice(1).trim();
+  }
+  if (!body) return { error: "Empty condition" };
+  const parsed = parseComparison(body);
+  if (_optionalChain([parsed, 'optionalAccess', _ => _.error]) !== void 0) return { error: parsed.error };
+  if (parsed) {
+    return { negated, name: parsed.subject, comparison: parsed.comparison };
+  }
+  if (/[=<>!]/.test(body)) {
+    return { error: `Malformed condition: ${text.trim()}` };
+  }
+  return { negated, name: body };
+}
+function evaluateConditionExpression(expression, values) {
+  return evaluateCondition(
+    expression.negated ? "unless" : "if",
+    expression.name,
+    values,
+    expression.comparison
+  );
+}
+function matchConditionalTags(tags) {
+  const result = tags.map(() => ({ partner: -1 }));
+  const stack = [];
+  const subjects = tags.map(
+    (tag) => tag.conditional === "end" ? void 0 : conditionSubject(tag.name)
+  );
+  tags.forEach((tag, index) => {
+    if (tag.conditional !== "end") {
+      stack.push(index);
+      return;
+    }
+    let depth = stack.length - 1;
+    while (depth >= 0 && tags[stack[depth]].name !== tag.name && subjects[stack[depth]] !== tag.name) {
+      depth--;
+    }
+    if (depth < 0) {
+      result[index].error = "unexpected-close";
+      return;
+    }
+    for (const skipped of stack.splice(depth + 1)) {
+      result[skipped].error = "unclosed-section";
+    }
+    const open = stack.pop();
+    if (tags[open].name !== tag.name) {
+      const comparison = parseComparison(tags[open].name);
+      result[open].comparison = result[index].comparison = comparison;
+      if (comparison.error !== void 0) {
+        result[open].error = result[index].error = "invalid-condition";
+        return;
+      }
+    }
+    result[open].partner = index;
+    result[index].partner = open;
+  });
+  for (const open of stack) {
+    result[open].error = "unclosed-section";
+  }
+  return result;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.TEMPLATE_REGEX = TEMPLATE_REGEX; exports.VARIABLE_REGEX = VARIABLE_REGEX; exports.INSTRUCTION_REGEX = INSTRUCTION_REGEX; exports.templateRegex = templateRegex; exports.variableRegex = variableRegex; exports.instructionRegex = instructionRegex; exports.unescapeVariableText = unescapeVariableText; exports.escapeVariableText = escapeVariableText; exports.parseVariableBody = parseVariableBody; exports.isPromptValueSet = isPromptValueSet; exports.getSuppliedValue = getSuppliedValue; exports.evaluateCondition = evaluateCondition; exports.compareConditionValues = compareConditionValues; exports.conditionSubject = conditionSubject; exports.parseComparison = parseComparison; exports.formatComparisonOperand = formatComparisonOperand; exports.formatConditionalTag = formatConditionalTag; exports.describeConditionalTag = describeConditionalTag; exports.parseConditionExpression = parseConditionExpression; exports.evaluateConditionExpression = evaluateConditionExpression; exports.matchConditionalTags = matchConditionalTags;
+//# sourceMappingURL=chunk-MKA3AHLV.cjs.map

package/dist/chunk-MKA3AHLV.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/editor/editor/packages/core/dist/chunk-MKA3AHLV.cjs","../src/grammar/tokens.ts","../src/grammar/variables.ts"],"names":[],"mappings":"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","file":"/home/runner/work/editor/editor/packages/core/dist/chunk-MKA3AHLV.cjs","sourcesContent":[null,"/**\n * Canonical regex patterns for prompt editing tokens.\n */\nexport const TEMPLATE_REGEX = /{{\\s*([^}]+?)\\s*}}/g;\n/**\n * `{name}`, `{name|default}`, `{name|default|description}` and the conditional\n * section tags `{?name}`, `{!name}` and `{/name}`. A backslash escapes the next\n * character, so `\\}`, `\\{` and `\\|` can appear inside defaults and descriptions.\n * Without backslashes this matches exactly what the original `[^{}]+` pattern did.\n */\nexport const VARIABLE_REGEX =\n  /(?<!\\{)\\{(?!\\})((?:\\\\[\\s\\S]|[^{}\\\\])*\\\\?)\\}(?!\\})/g;\nexport const INSTRUCTION_REGEX = /__(.+?)__/g;\n\n// Backward-compatible camelCase aliases\nexport const templateRegex = TEMPLATE_REGEX;\nexport const variableRegex = VARIABLE_REGEX;\nexport const instructionRegex = INSTRUCTION_REGEX;\n\nexport type TokenType =\n  | \"template\"\n  | \"variable\"\n  | \"instruction\"\n  | \"conditional\"\n  | \"text\";\n\n/**\n * Kind of a conditional section tag: `{?name}` opens a section kept when\n * `name` has a value, `{!name}` opens one kept when it has none, and\n * `{/name}` closes either.\n */\nexport type ConditionalKind = \"if\" | \"unless\" | \"end\";\n\nexport interface Token {\n  type: TokenType;\n  raw: string;\n  /** Trimmed name for templates, variables and conditional tags; content otherwise. */\n  value: string;\n  start: number;\n  end: number;\n  /** Variables only: unescaped text after the first `|` (may be empty). */\n  defaultValue?: string;\n  /** Variables only: unescaped text after the second `|` (fill-in prompt). */\n  description?: string;\n  /** Conditional tags only. */\n  conditional?: ConditionalKind;\n  /**\n   * Opening conditional tags written as a comparison (`{?amount>100}`,\n   * closed by `{/amount}`) only. `value` is then the variable name.\n   */\n  comparison?: ConditionComparison;\n}\n\n/** Operators accepted in a comparison condition such as `{?amount>=100}`. */\nexport type ComparisonOperator = \"=\" | \"<>\" | \"<\" | \">\" | \"<=\" | \">=\";\n\n/** The comparison part of a conditional tag: `{?status=paid}` → `{ operator: \"=\", operand: \"paid\" }`. */\nexport interface ConditionComparison {\n  operator: ComparisonOperator;\n  /** Right-hand side, unquoted. */\n  operand: string;\n}\n\n/** Values supplied for `{variable}` slots and `{?variable}` conditions. */\nexport type PromptValue = string | number | boolean | null | undefined;\nexport type PromptValues = Record<string, PromptValue>;\n\nexport type PromptDiagnosticCode =\n  | \"unclosed-section\"\n  | \"unexpected-close\"\n  | \"invalid-condition\";\n\n/**\n * A recoverable grammar problem. The offending tag is treated as literal text.\n * Offsets are relative to the text that contained the tag: the input prompt,\n * or the body of `templateName` when set.\n */\nexport interface PromptDiagnostic {\n  code: PromptDiagnosticCode;\n  message: string;\n  /** Variable named by the tag. */\n  name: string;\n  start: number;\n  end: number;\n  templateName?: string;\n}\n\nexport interface TemplateVersion {\n  id: string;\n  version: string | number;\n  body: string;\n  createdAt?: any;\n  [key: string]: any;\n}\n\nexport interface Template {\n  id?: string;\n  name: string;\n  body?: string;\n  latestVersion?: string | number;\n  versions?: TemplateVersion[];\n  color?: string;\n  [key: string]: any;\n}\n\nexport interface ColorGradient {\n  from: string;\n  to: string;\n}\n","// Portions ported from wordcraft/crates/engine/src/cmd/mailings.rs (MIT OR\n// Apache-2.0, © ArtCraft Team and contributors). See THIRD_PARTY_NOTICES.md.\nimport type {\n  ComparisonOperator,\n  ConditionComparison,\n  ConditionalKind,\n  PromptValue,\n  PromptValues,\n} from \"./tokens\";\n\n/** Result of classifying the text between the braces of a `{…}` token. */\nexport type ParsedVariableBody =\n  | {\n      kind: \"variable\";\n      name: string;\n      defaultValue?: string;\n      description?: string;\n    }\n  | {\n      kind: \"conditional\";\n      conditional: ConditionalKind;\n      name: string;\n    };\n\nconst CONDITIONAL_PREFIXES: Record<string, ConditionalKind> = {\n  \"?\": \"if\",\n  \"!\": \"unless\",\n  \"/\": \"end\",\n};\n\n/**\n * Removes grammar escapes: `\\|`, `\\{`, `\\}` and `\\\\` become the bare character.\n * Any other backslash is kept, so Windows paths and regex-like text survive.\n */\nexport function unescapeVariableText(text: string): string {\n  return text.replace(/\\\\([\\\\{}|])/g, \"$1\");\n}\n\n/**\n * Escapes text so it can be embedded as a variable default or description.\n */\nexport function escapeVariableText(text: string): string {\n  return text.replace(/[\\\\{}|]/g, (ch) => `\\\\${ch}`);\n}\n\n/** Splits on `|` characters that are not escaped with a backslash. */\nfunction splitUnescapedPipes(body: string, limit: number): string[] {\n  const parts: string[] = [];\n  let current = \"\";\n  for (let i = 0; i < body.length; i++) {\n    const ch = body[i];\n    if (ch === \"\\\\\" && i + 1 < body.length) {\n      current += ch + body[i + 1];\n      i++;\n      continue;\n    }\n    if (ch === \"|\" && parts.length < limit - 1) {\n      parts.push(current);\n      current = \"\";\n      continue;\n    }\n    current += ch;\n  }\n  parts.push(current);\n  return parts;\n}\n\n/**\n * Classifies the inner text of a `{…}` token.\n *\n * - `{?name}`, `{!name}`, `{/name}` are conditional section tags. The name may\n *   not contain `|`; otherwise the token is an ordinary variable.\n * - `{name|default|description}` is a variable. Each part is trimmed and\n *   unescaped. A default is present whenever a `|` is (it may be empty), and\n *   anything after the second unescaped `|` belongs to the description.\n */\nexport function parseVariableBody(inner: string): ParsedVariableBody {\n  const prefix = CONDITIONAL_PREFIXES[inner[0]];\n  if (prefix) {\n    const name = inner.slice(1).trim();\n    if (name && !/[|\\\\]/.test(name)) {\n      return { kind: \"conditional\", conditional: prefix, name };\n    }\n  }\n\n  const [rawName, rawDefault, rawDescription] = splitUnescapedPipes(inner, 3);\n  const parsed: ParsedVariableBody = {\n    kind: \"variable\",\n    name: unescapeVariableText(rawName.trim()),\n  };\n  if (rawDefault !== undefined) {\n    parsed.defaultValue = unescapeVariableText(rawDefault.trim());\n  }\n  if (rawDescription !== undefined) {\n    parsed.description = unescapeVariableText(rawDescription.trim());\n  }\n  return parsed;\n}\n\n/**\n * Whether a supplied value counts as \"set\" for a `{?name}` condition:\n * not `null`/`undefined`/`false`, and not blank once stringified.\n */\nexport function isPromptValueSet(value: PromptValue): boolean {\n  if (value === null || value === undefined || value === false) return false;\n  return String(value).trim() !== \"\";\n}\n\n/**\n * Returns the text a supplied value substitutes, or `undefined` when the\n * variable should fall back to its default. An explicit empty string is a\n * value (it renders as nothing); `null`/`undefined` are not.\n */\nexport function getSuppliedValue(\n  values: PromptValues,\n  name: string,\n): string | undefined {\n  if (!Object.prototype.hasOwnProperty.call(values, name)) return undefined;\n  const value = values[name];\n  if (value === null || value === undefined) return undefined;\n  return String(value);\n}\n\n/**\n * Whether a section opened by `{?name}` / `{!name}` keeps its body. With a\n * `comparison` (from `{?name>3}`), the supplied value is compared instead of\n * tested for presence; a missing value compares as `\"\"`.\n */\nexport function evaluateCondition(\n  conditional: Exclude<ConditionalKind, \"end\">,\n  name: string,\n  values: PromptValues,\n  comparison?: ConditionComparison,\n): boolean {\n  const holds = comparison\n    ? compareConditionValues(\n        getSuppliedValue(values, name) ?? \"\",\n        comparison.operator,\n        comparison.operand,\n      )\n    : isPromptValueSet(values[name]);\n  return conditional === \"if\" ? holds : !holds;\n}\n\nconst NUMBER_PATTERN = /^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?$/i;\n\n/** Parses a plain decimal number (surrounding whitespace allowed), or `undefined`. */\nfunction parseComparableNumber(text: string): number | undefined {\n  const trimmed = text.trim();\n  if (!NUMBER_PATTERN.test(trimmed)) return undefined;\n  const value = Number(trimmed);\n  return Number.isFinite(value) ? value : undefined;\n}\n\n/**\n * Compares two texts like a mail-merge `IF` field: as numbers when both parse\n * as plain decimal numbers (so `\"7\"` equals `\"7.0\"`), otherwise as\n * case-insensitive text.\n */\nexport function compareConditionValues(\n  left: string,\n  operator: ComparisonOperator,\n  right: string,\n): boolean {\n  const a = parseComparableNumber(left);\n  const b = parseComparableNumber(right);\n  let order: number;\n  if (a !== undefined && b !== undefined) {\n    order = a === b ? 0 : a < b ? -1 : 1;\n  } else {\n    const x = left.toLowerCase();\n    const y = right.toLowerCase();\n    order = x === y ? 0 : x < y ? -1 : 1;\n  }\n  switch (operator) {\n    case \"=\":\n      return order === 0;\n    case \"<>\":\n      return order !== 0;\n    case \"<\":\n      return order < 0;\n    case \">\":\n      return order > 0;\n    case \"<=\":\n      return order <= 0;\n    case \">=\":\n      return order >= 0;\n    default:\n      return false;\n  }\n}\n\n/**\n * Subject, operator and rest of a comparison. The subject runs up to the\n * first `=`, `<`, `>` or `!=` and may not contain `!`.\n */\nconst COMPARISON_PATTERN = /^([^=<>!]+?)\\s*(<>|<=|>=|!=|=|<|>)\\s*([\\s\\S]*)$/;\n\n/**\n * The variable a conditional tag name compares when it is written as a\n * comparison (`amount>100` → `amount`), or `undefined`. A tag only acts as a\n * comparison when it is closed by `{/subject}`.\n */\nexport function conditionSubject(name: string): string | undefined {\n  const match = COMPARISON_PATTERN.exec(name.trim());\n  if (!match) return undefined;\n  return match[1].trim() || undefined;\n}\n\nexport type ParsedComparison =\n  | { subject: string; comparison: ConditionComparison; error?: undefined }\n  | { subject: string; comparison?: undefined; error: string };\n\n/**\n * Parses a comparison condition such as `amount >= 100`, `status=paid`,\n * `status <> \"on hold\"` or `note=\"\"`. Returns `undefined` when `text` has no\n * subject and operator, or an `error` when the comparison is malformed\n * (missing value, doubled operator, unterminated quote). `!=` is accepted as\n * a synonym for `<>`.\n */\nexport function parseComparison(text: string): ParsedComparison | undefined {\n  const match = COMPARISON_PATTERN.exec(text.trim());\n  if (!match) return undefined;\n  const subject = match[1].trim();\n  if (!subject) return undefined;\n  const written = match[2];\n  const operator = (written === \"!=\" ? \"<>\" : written) as ComparisonOperator;\n  const rest = match[3];\n  if (rest === \"\") {\n    return {\n      subject,\n      error: `Missing value after \"${written}\" (write \"\" to compare with an empty value)`,\n    };\n  }\n  if (rest.startsWith('\"')) {\n    if (rest.length < 2 || !rest.endsWith('\"')) {\n      return { subject, error: `Unterminated quote in ${rest}` };\n    }\n    return { subject, comparison: { operator, operand: rest.slice(1, -1) } };\n  }\n  if (/^[=<>!]/.test(rest)) {\n    return {\n      subject,\n      error: `Unexpected \"${rest[0]}\" after \"${written}\"; operators are = <> < > <= >=`,\n    };\n  }\n  return { subject, comparison: { operator, operand: rest } };\n}\n\n/** Writes a comparison operand back as condition text, quoting it when needed. */\nexport function formatComparisonOperand(operand: string): string {\n  return operand === \"\" ||\n    operand !== operand.trim() ||\n    /^[=<>!\"]/.test(operand)\n    ? `\"${operand}\"`\n    : operand;\n}\n\n/**\n * The display form of a conditional tag: `{?name}`, `{!name}`, `{/name}`, or\n * `{?amount>100}` for a comparison.\n */\nexport function formatConditionalTag(tag: {\n  conditional?: ConditionalKind;\n  value: string;\n  comparison?: ConditionComparison;\n}): string {\n  const prefix =\n    tag.conditional === \"unless\" ? \"!\" : tag.conditional === \"end\" ? \"/\" : \"?\";\n  const comparison = tag.comparison\n    ? `${tag.comparison.operator}${formatComparisonOperand(tag.comparison.operand)}`\n    : \"\";\n  return `{${prefix}${tag.value}${comparison}}`;\n}\n\n/** A tooltip for a conditional tag, e.g. `Shown when \"amount\" > 100`. */\nexport function describeConditionalTag(tag: {\n  conditional?: ConditionalKind;\n  value: string;\n  comparison?: ConditionComparison;\n}): string {\n  if (tag.conditional === \"end\") return `End of section: ${tag.value}`;\n  const shown = tag.conditional === \"unless\" ? \"Hidden\" : \"Shown\";\n  if (tag.comparison) {\n    return `${shown} when \"${tag.value}\" ${tag.comparison.operator} ${formatComparisonOperand(tag.comparison.operand)}`;\n  }\n  return tag.conditional === \"unless\"\n    ? `Shown when \"${tag.value}\" is empty`\n    : `Shown when \"${tag.value}\" has a value`;\n}\n\n/** A parsed standalone condition (see `parseConditionExpression`). */\nexport interface ConditionExpression {\n  /** `true` for `!name` / `!name=value`: the condition is inverted. */\n  negated: boolean;\n  name: string;\n  comparison?: ConditionComparison;\n}\n\n/**\n * Parses a condition written like the inside of a section tag, without the\n * braces: `vip` (has a value), `!vip` (has none), `amount>100`,\n * `!status=paid`. A leading `?` is allowed. Used by options such as\n * `mergeRecords({ skipIf })`. Returns `{ error }` for malformed text.\n */\nexport function parseConditionExpression(\n  text: string,\n): ConditionExpression | { error: string } {\n  let body = text.trim();\n  let negated = false;\n  if (body.startsWith(\"!\")) {\n    negated = true;\n    body = body.slice(1).trim();\n  } else if (body.startsWith(\"?\")) {\n    body = body.slice(1).trim();\n  }\n  if (!body) return { error: \"Empty condition\" };\n  const parsed = parseComparison(body);\n  if (parsed?.error !== undefined) return { error: parsed.error };\n  if (parsed) {\n    return { negated, name: parsed.subject, comparison: parsed.comparison };\n  }\n  if (/[=<>!]/.test(body)) {\n    return { error: `Malformed condition: ${text.trim()}` };\n  }\n  return { negated, name: body };\n}\n\n/** Evaluates a parsed condition expression against values. */\nexport function evaluateConditionExpression(\n  expression: ConditionExpression,\n  values: PromptValues,\n): boolean {\n  return evaluateCondition(\n    expression.negated ? \"unless\" : \"if\",\n    expression.name,\n    values,\n    expression.comparison,\n  );\n}\n\nexport interface ConditionalTagLike {\n  conditional: ConditionalKind;\n  name: string;\n}\n\nexport interface ConditionalTagMatch {\n  /** Index of the partner tag, or -1 when the tag is unbalanced. */\n  partner: number;\n  /** Set when unbalanced, or on both tags of a malformed comparison pair. */\n  error?: \"unclosed-section\" | \"unexpected-close\" | \"invalid-condition\";\n  /**\n   * Set on both tags of a pair whose open tag is a comparison closed by its\n   * subject (`{?amount>100}…{/amount}`).\n   */\n  comparison?: ParsedComparison;\n}\n\n/**\n * Pairs conditional tags given in document order. A close tag pairs with the\n * nearest open tag of the same name, or with the nearest open comparison tag\n * whose subject it names (`{?amount>100}` is closed by `{/amount}`; closing\n * it with `{/amount>100}` keeps the old meaning, a presence check on a\n * variable named `amount>100`). Open tags skipped over are reported as\n * unclosed, a close tag with no open partner as unexpected, and a malformed\n * comparison pair as an invalid condition. Unbalanced tags never throw:\n * callers treat them as literal text. The surviving pairs are always properly\n * nested.\n */\nexport function matchConditionalTags(\n  tags: ConditionalTagLike[],\n): ConditionalTagMatch[] {\n  const result: ConditionalTagMatch[] = tags.map(() => ({ partner: -1 }));\n  const stack: number[] = [];\n  const subjects = tags.map((tag) =>\n    tag.conditional === \"end\" ? undefined : conditionSubject(tag.name),\n  );\n\n  tags.forEach((tag, index) => {\n    if (tag.conditional !== \"end\") {\n      stack.push(index);\n      return;\n    }\n    let depth = stack.length - 1;\n    while (\n      depth >= 0 &&\n      tags[stack[depth]].name !== tag.name &&\n      subjects[stack[depth]] !== tag.name\n    ) {\n      depth--;\n    }\n    if (depth < 0) {\n      result[index].error = \"unexpected-close\";\n      return;\n    }\n    // Everything opened after the partner was never closed.\n    for (const skipped of stack.splice(depth + 1)) {\n      result[skipped].error = \"unclosed-section\";\n    }\n    const open = stack.pop()!;\n    if (tags[open].name !== tag.name) {\n      const comparison = parseComparison(tags[open].name)!;\n      result[open].comparison = result[index].comparison = comparison;\n      if (comparison.error !== undefined) {\n        result[open].error = result[index].error = \"invalid-condition\";\n        return;\n      }\n    }\n    result[open].partner = index;\n    result[index].partner = open;\n  });\n\n  for (const open of stack) {\n    result[open].error = \"unclosed-section\";\n  }\n  return result;\n}\n"]}