@spintax/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1027 @@
+'use strict';
+
+// src/internal/ast.ts
+var AST_VERSION = 1;
+function walk(nodes, visit) {
+  for (const n of nodes) {
+    visit(n);
+    switch (n.type) {
+      case "enumeration":
+        for (const opt of n.options) walk(opt, visit);
+        break;
+      case "conditional":
+        walk(n.then, visit);
+        walk(n.else, visit);
+        break;
+      case "permutation":
+        for (const opt of n.options) walk(opt.nodes, visit);
+        break;
+    }
+  }
+}
+function isParsedAst(value) {
+  return typeof value === "object" && value !== null && value.astVersion === AST_VERSION && typeof value.source === "string" && Array.isArray(value.nodes);
+}
+
+// src/internal/parser.ts
+var VARIABLE_RE = /^%(\w+)%/;
+var SET_DIRECTIVE_RE = /^[ \t]*#set[ \t]+%(\w+)%[ \t]*=[ \t]*(.*?)[ \t]*\r?$/gmu;
+var CONDITIONAL_NAME_RE = /^[A-Za-z_]\w*/;
+var PLURAL_PREFIX = "plural ";
+function parseTemplate(src) {
+  const { body, setDefs } = extractSetDirectives(stripComments(src));
+  return { astVersion: AST_VERSION, source: src, setDefs, nodes: parseSequence(body) };
+}
+function extractSetDirectives(text) {
+  const setDefs = {};
+  SET_DIRECTIVE_RE.lastIndex = 0;
+  const stripped = text.replace(SET_DIRECTIVE_RE, (_full, name, value) => {
+    setDefs[name.toLowerCase()] = value;
+    return "";
+  });
+  return { body: stripped.replace(/\n{3,}/gu, "\n\n"), setDefs };
+}
+function stripComments(text) {
+  return text.replace(/\/#[\s\S]*?#\//g, "");
+}
+function parseSequence(text) {
+  const nodes = [];
+  let literal = "";
+  let i = 0;
+  const flushLiteral = () => {
+    if (literal !== "") {
+      nodes.push({ type: "literal", value: literal });
+      literal = "";
+    }
+  };
+  while (i < text.length) {
+    const ch = text.charAt(i);
+    if (ch === "{") {
+      const end = findMatchingClose(text, i, "{", "}");
+      if (end === -1) {
+        literal += ch;
+        i += 1;
+        continue;
+      }
+      const content = text.slice(i + 1, end);
+      flushLiteral();
+      nodes.push(parseBraceConstruct(content));
+      i = end + 1;
+      continue;
+    }
+    if (ch === "[") {
+      const end = findMatchingClose(text, i, "[", "]");
+      if (end === -1) {
+        literal += ch;
+        i += 1;
+        continue;
+      }
+      flushLiteral();
+      nodes.push(parsePermutation(text.slice(i + 1, end)));
+      i = end + 1;
+      continue;
+    }
+    if (ch === "%") {
+      const name = VARIABLE_RE.exec(text.slice(i))?.[1];
+      if (name !== void 0) {
+        flushLiteral();
+        nodes.push({ type: "variable", name });
+        i += name.length + 2;
+        continue;
+      }
+    }
+    literal += ch;
+    i += 1;
+  }
+  flushLiteral();
+  return nodes;
+}
+function parseBraceConstruct(content) {
+  if (content.charAt(0) === "?") {
+    const cond = tryParseConditional(content);
+    if (cond) return cond;
+  } else if (content.startsWith(PLURAL_PREFIX) && content.slice(PLURAL_PREFIX.length).includes(":")) {
+    return parsePlural(content.slice(PLURAL_PREFIX.length));
+  }
+  return { type: "enumeration", options: splitTopLevel(content).map((o) => parseSequence(o)) };
+}
+function tryParseConditional(content) {
+  let p = 1;
+  let inverted = false;
+  if (content.charAt(p) === "!") {
+    inverted = true;
+    p += 1;
+  }
+  const name = CONDITIONAL_NAME_RE.exec(content.slice(p))?.[0];
+  if (name === void 0) return null;
+  p += name.length;
+  if (content.charAt(p) !== "?") return null;
+  p += 1;
+  const body = content.slice(p);
+  const sep = firstTopLevelPipe(body);
+  const thenRaw = sep < 0 ? body : body.slice(0, sep);
+  const elseRaw = sep < 0 ? "" : body.slice(sep + 1);
+  return {
+    type: "conditional",
+    name,
+    inverted,
+    then: parseSequence(thenRaw),
+    else: parseSequence(elseRaw)
+  };
+}
+function parsePlural(afterPrefix) {
+  const colon = afterPrefix.indexOf(":");
+  return { type: "plural", countRaw: afterPrefix.slice(0, colon), formsRaw: afterPrefix.slice(colon + 1) };
+}
+var CONFIG_KEY_RE = /\b(?:minsize|maxsize|sep|lastsep)\s*=/i;
+var MINSIZE_RE = /minsize\s*=\s*(\d+)/i;
+var MAXSIZE_RE = /maxsize\s*=\s*(\d+)/i;
+var SEP_RE = /(?<!last)sep\s*=\s*"([^"]*)"/i;
+var LASTSEP_RE = /lastsep\s*=\s*"([^"]*)"/i;
+var HTML_TAG_RE = /^([a-zA-Z][a-zA-Z0-9-]*)(?:\s+[^>]*)?\/?$/;
+var PER_ELEM_HTML_RE = /^[a-zA-Z][a-zA-Z0-9]*\s/;
+function defaultPermConfig() {
+  return { minsize: null, maxsize: null, sep: " ", lastsep: null };
+}
+function parsePermutation(rawInner) {
+  const { config, content } = extractPermutationConfig(rawInner);
+  const options = extractPerElementSeparators(splitTopLevel(content));
+  return { type: "permutation", config, options };
+}
+function extractPermutationConfig(content) {
+  const trimmed = phpLtrim(content);
+  if (trimmed === "" || trimmed.charAt(0) !== "<") {
+    return { config: defaultPermConfig(), content };
+  }
+  const end = findConfigEnd(trimmed);
+  if (end === -1) return { config: defaultPermConfig(), content };
+  const configStr = trimmed.slice(1, end);
+  const remaining = trimmed.slice(end + 1);
+  if (looksLikeHtmlStartTag(configStr, remaining)) {
+    return { config: defaultPermConfig(), content };
+  }
+  return { config: parseConfigString(configStr), content: remaining };
+}
+function findConfigEnd(text) {
+  let inQuote = false;
+  for (let i = 1; i < text.length; i += 1) {
+    const ch = text.charAt(i);
+    if (ch === '"') inQuote = !inQuote;
+    if (ch === ">" && !inQuote) return i;
+  }
+  return -1;
+}
+function parseConfigString(str) {
+  if (!CONFIG_KEY_RE.test(str)) {
+    return { minsize: null, maxsize: null, sep: str, lastsep: str };
+  }
+  return {
+    minsize: intGroup(MINSIZE_RE.exec(str)),
+    maxsize: intGroup(MAXSIZE_RE.exec(str)),
+    sep: strGroup(SEP_RE.exec(str)) ?? " ",
+    lastsep: strGroup(LASTSEP_RE.exec(str))
+  };
+}
+function looksLikeHtmlStartTag(tagText, remaining) {
+  const trimmed = phpTrim(tagText);
+  if (trimmed === "") return false;
+  const m = HTML_TAG_RE.exec(trimmed);
+  if (!m) return false;
+  if (trimmed.endsWith("/")) return true;
+  const tagName = (m[1] ?? "").toLowerCase();
+  return new RegExp(`</${escapeRegExp(tagName)}\\s*>`, "iu").test(remaining);
+}
+function extractPerElementSeparators(rawParts) {
+  const options = [];
+  let pendingSep = null;
+  rawParts.forEach((part, i) => {
+    let text = part;
+    let trailingSep = null;
+    if (i < rawParts.length - 1) {
+      const extracted = extractTrailingSep(part);
+      if (extracted) {
+        text = extracted.text;
+        trailingSep = extracted.sep;
+      }
+    }
+    const trimmed = phpTrim(text);
+    if (trimmed !== "") {
+      options.push({ nodes: parseSequence(trimmed), separator: pendingSep });
+    }
+    pendingSep = trailingSep;
+  });
+  return options;
+}
+function extractTrailingSep(part) {
+  const trimmed = phpRtrim(part);
+  const len = trimmed.length;
+  if (len === 0 || trimmed.charAt(len - 1) !== ">") return null;
+  let openPos = -1;
+  for (let i = len - 2; i >= 0; i -= 1) {
+    const ch = trimmed.charAt(i);
+    if (ch === "<") {
+      openPos = i;
+      break;
+    }
+    if (ch === ">") return null;
+  }
+  if (openPos === -1) return null;
+  const inner = trimmed.slice(openPos + 1, len - 1);
+  const innerTrimmed = phpTrim(inner);
+  if (innerTrimmed.startsWith("/") || innerTrimmed.endsWith("/") || PER_ELEM_HTML_RE.test(innerTrimmed)) {
+    return null;
+  }
+  return { text: trimmed.slice(0, openPos), sep: inner };
+}
+function intGroup(m) {
+  return m && m[1] !== void 0 ? Number.parseInt(m[1], 10) : null;
+}
+function strGroup(m) {
+  return m && m[1] !== void 0 ? m[1] : null;
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+var PHP_LTRIM_RE = /^[ \t\n\r\0\x0B]+/u;
+var PHP_RTRIM_RE = /[ \t\n\r\0\x0B]+$/u;
+function phpTrim(s) {
+  return s.replace(PHP_LTRIM_RE, "").replace(PHP_RTRIM_RE, "");
+}
+function phpLtrim(s) {
+  return s.replace(PHP_LTRIM_RE, "");
+}
+function phpRtrim(s) {
+  return s.replace(PHP_RTRIM_RE, "");
+}
+function findMatchingClose(text, openPos, open, close) {
+  let depth = 0;
+  for (let i = openPos; i < text.length; i += 1) {
+    const ch = text.charAt(i);
+    if (ch === open) {
+      depth += 1;
+    } else if (ch === close) {
+      depth -= 1;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+function splitTopLevel(inner) {
+  const parts = [];
+  let brace = 0;
+  let bracket = 0;
+  let cur = "";
+  for (const ch of inner) {
+    if (ch === "{") brace += 1;
+    else if (ch === "}") brace -= 1;
+    else if (ch === "[") bracket += 1;
+    else if (ch === "]") bracket -= 1;
+    if (ch === "|" && brace === 0 && bracket === 0) {
+      parts.push(cur);
+      cur = "";
+    } else {
+      cur += ch;
+    }
+  }
+  parts.push(cur);
+  return parts;
+}
+function firstTopLevelPipe(body) {
+  let depth = 0;
+  for (let j = 0; j < body.length; j += 1) {
+    const ch = body.charAt(j);
+    if (ch === "{" || ch === "[") {
+      depth += 1;
+    } else if (ch === "}" || ch === "]") {
+      if (depth > 0) depth -= 1;
+    } else if (ch === "|" && depth === 0) {
+      return j;
+    }
+  }
+  return -1;
+}
+
+// src/internal/plurals.ts
+var PLURAL_PREFIX2 = "{plural ";
+function findPluralBlocks(text) {
+  const blocks = [];
+  let i = 0;
+  while (i < text.length) {
+    const start = text.indexOf(PLURAL_PREFIX2, i);
+    if (start === -1) break;
+    let depth = 1;
+    let j = start + PLURAL_PREFIX2.length;
+    while (j < text.length) {
+      const ch = text.charAt(j);
+      if (ch === "{") depth += 1;
+      else if (ch === "}") {
+        depth -= 1;
+        if (depth === 0) break;
+      }
+      j += 1;
+    }
+    if (depth !== 0) {
+      i = start + PLURAL_PREFIX2.length;
+      continue;
+    }
+    const inner = text.slice(start + PLURAL_PREFIX2.length, j);
+    const colon = inner.indexOf(":");
+    if (colon === -1) {
+      i = j + 1;
+      continue;
+    }
+    blocks.push({ start, countSlot: inner.slice(0, colon), formsRaw: inner.slice(colon + 1) });
+    i = j + 1;
+  }
+  return blocks;
+}
+function normalizeBaseLang(locale) {
+  const first = locale.toLowerCase().split(/[-_]/, 1)[0];
+  return first ?? "";
+}
+function pluralArity(baseLang) {
+  switch (baseLang) {
+    case "ru":
+    case "uk":
+    case "be":
+      return 3;
+    default:
+      return 2;
+  }
+}
+function pluralFor(baseLang, n, forms) {
+  const abs = Math.abs(n);
+  const mod10 = abs % 10;
+  const mod100 = abs % 100;
+  switch (baseLang) {
+    case "ru":
+    case "uk":
+    case "be":
+      if (mod10 === 1 && mod100 !== 11) return forms[0] ?? "";
+      if (mod10 >= 2 && mod10 <= 4 && (mod100 < 12 || mod100 > 14)) return forms[1] ?? "";
+      return forms[2] ?? "";
+    default:
+      return (abs === 1 ? forms[0] : forms[1]) ?? "";
+  }
+}
+
+// src/internal/validator.ts
+var KNOWN_CONFIG_KEYS = /* @__PURE__ */ new Set(["minsize", "maxsize", "sep", "lastsep"]);
+var INCLUDE_RE = /^[ \t]*#include[ \t\n\r\f\x0B]+"([^"]+)"[ \t\n\r\f\x0B]*$/gmu;
+function validateTemplate(src, opts = {}) {
+  const diagnostics = [];
+  const text = stripComments(src);
+  checkBrackets(text, diagnostics);
+  checkSetDirectives(text, diagnostics);
+  checkPermutationConfigs(text, diagnostics);
+  checkPlurals(text, opts.locale, diagnostics);
+  checkVariableReferences(text, opts.knownVariables, diagnostics);
+  if (opts.knownIncludes && opts.knownIncludes.length > 0) {
+    checkIncludeTargets(text, opts.knownIncludes, diagnostics);
+  }
+  return diagnostics;
+}
+function err(code, message, line = 1, column = 1) {
+  return { severity: "error", code, message, line, column };
+}
+function warn(code, message, line = 1, column = 1) {
+  return { severity: "warning", code, message, line, column };
+}
+function checkBrackets(text, out) {
+  const close = { "{": "}", "[": "]" };
+  const stack = [];
+  let line = 1;
+  let column = 1;
+  for (const ch of text) {
+    if (ch === "\n") {
+      line += 1;
+      column = 1;
+      continue;
+    }
+    if (ch === "{" || ch === "[") {
+      stack.push({ char: ch, expect: close[ch], line, column });
+    } else if (ch === "}" || ch === "]") {
+      const top = stack.pop();
+      if (top === void 0) {
+        out.push(err("bracket.unexpected-closing", `Unexpected closing '${ch}'.`, line, column));
+      } else if (top.expect !== ch) {
+        out.push(err("bracket.mismatched", `'${top.char}' closed by '${ch}'.`, line, column));
+      }
+    }
+    column += 1;
+  }
+  for (const unclosed of stack) {
+    out.push(err("bracket.unclosed", `Unclosed '${unclosed.char}'.`, unclosed.line, unclosed.column));
+  }
+}
+function checkSetDirectives(text, out) {
+  const lines = text.split("\n");
+  lines.forEach((lineText, idx) => {
+    const trimmed = lineText.replace(/^[ \t]+/, "");
+    if (!trimmed.startsWith("#set ") && !trimmed.startsWith("#set	")) return;
+    if (!/^#set\s+%(\w+)%\s*=\s*(.+)$/u.test(trimmed)) {
+      out.push(err("set.malformed", "Malformed #set. Expected: #set %name% = value", idx + 1));
+    }
+  });
+}
+function checkPermutationConfigs(text, out) {
+  for (const m of text.matchAll(/\[<([^>]*?)>/gu)) {
+    const configStr = m[1] ?? "";
+    if (!/\w+\s*=/.test(configStr)) continue;
+    const line = countLines(text, m.index ?? 0);
+    for (const km of configStr.matchAll(/(\w+)\s*=/gu)) {
+      const key = (km[1] ?? "").toLowerCase();
+      if (!KNOWN_CONFIG_KEYS.has(key)) {
+        out.push(err("permutation.unknown-key", `Unknown permutation config key: '${km[1]}'.`, line));
+      }
+    }
+    const min = /minsize\s*=\s*([^;>\s]+)/i.exec(configStr);
+    if (min && !/^\d+$/.test(min[1] ?? "")) {
+      out.push(err("permutation.minsize-not-integer", `minsize must be a positive integer, got '${min[1]}'.`, line));
+    }
+    const max = /maxsize\s*=\s*([^;>\s]+)/i.exec(configStr);
+    if (max && !/^\d+$/.test(max[1] ?? "")) {
+      out.push(err("permutation.maxsize-not-integer", `maxsize must be a positive integer, got '${max[1]}'.`, line));
+    }
+  }
+}
+function checkPlurals(text, locale, out) {
+  const base = locale && locale !== "" ? normalizeBaseLang(locale) : "";
+  const arity = base !== "" ? pluralArity(base) : 0;
+  for (const block of findPluralBlocks(text)) {
+    const line = countLines(text, block.start);
+    if (/[{}[\]]/.test(block.formsRaw)) {
+      out.push(err("plural.nested-brackets", "{plural ...}: forms must not contain nested spintax brackets.", line));
+      continue;
+    }
+    if (arity > 0) {
+      const count = block.formsRaw.split("|").length;
+      if (count !== arity) {
+        out.push(err("plural.arity", `{plural ...}: expected ${arity} forms, got ${count}.`, line));
+      }
+    }
+  }
+}
+function checkVariableReferences(text, known, out) {
+  const knownSet = new Set((known ?? []).map((n) => n.toLowerCase()));
+  const defs = /* @__PURE__ */ new Map();
+  for (const m of text.matchAll(/^[ \t]*#set[ \t]+%(\w+)%[ \t]*=[ \t]*(.*?)$/gmu)) {
+    defs.set((m[1] ?? "").toLowerCase(), m[2] ?? "");
+  }
+  for (const [name, value] of defs) {
+    if (value.toLowerCase().includes(`%${name}%`)) {
+      out.push(err("variable.self-reference", `Variable '${name}' references itself.`));
+    }
+  }
+  for (const name of defs.keys()) {
+    detectCycle(name, defs, [name], out);
+  }
+  const body = text.replace(/^[ \t]*#set[ \t]+%\w+%[ \t]*=[ \t]*.*?$/gmu, "");
+  const refs = /* @__PURE__ */ new Set();
+  for (const m of body.matchAll(/%(\w+)%/gu)) refs.add((m[1] ?? "").toLowerCase());
+  for (const m of body.matchAll(/\{\?!?([A-Za-z_]\w*)\?/gu)) refs.add((m[1] ?? "").toLowerCase());
+  for (const ref of refs) {
+    if (!defs.has(ref) && !knownSet.has(ref)) {
+      out.push(warn("variable.undefined", `Variable '${ref}' is not defined \u2014 may be a runtime variable.`));
+    }
+  }
+}
+function detectCycle(current, defs, visited, out) {
+  const value = defs.get(current) ?? "";
+  for (const m of value.matchAll(/%(\w+)%/gu)) {
+    const ref = (m[1] ?? "").toLowerCase();
+    if (ref === current) continue;
+    if (visited.includes(ref)) {
+      out.push(err("variable.circular-reference", `Circular variable reference: ${[...visited, ref].join(" \u2192 ")}.`));
+      return;
+    }
+    if (defs.has(ref)) detectCycle(ref, defs, [...visited, ref], out);
+  }
+}
+function checkIncludeTargets(text, known, out) {
+  const set = new Set(known);
+  INCLUDE_RE.lastIndex = 0;
+  for (const m of text.matchAll(INCLUDE_RE)) {
+    const ref = m[1] ?? "";
+    if (!set.has(ref)) {
+      out.push(
+        err("include.unknown-target", `#include target '${ref}' does not match any known template.`, countLines(text, m.index ?? 0))
+      );
+    }
+  }
+}
+function countLines(text, offset) {
+  let n = 1;
+  for (let i = 0; i < offset && i < text.length; i += 1) {
+    if (text.charAt(i) === "\n") n += 1;
+  }
+  return n;
+}
+
+// src/internal/extract.ts
+var SET_DEF_RE = /^[ \t]*#set[ \t]+%(\w+)%[ \t]*=/gmu;
+var SET_LHS_RE = /^[ \t]*#set[ \t]+%\w+%[ \t]*=/gmu;
+var INCLUDE_RE2 = /^[ \t]*#include[ \t\n\r\f\x0B]+"([^"]+)"[ \t\n\r\f\x0B]*$/gmu;
+var VARIABLE_RE2 = /%(\w+)%/gu;
+var CONDITIONAL_REF_RE = /\{\?!?([A-Za-z_]\w*)\?/gu;
+function extractFromSource(src) {
+  const text = stripComments(src);
+  const sets = collect(text, SET_DEF_RE, true);
+  const includes = collect(text, INCLUDE_RE2, false);
+  const body = text.replace(SET_LHS_RE, "");
+  const refs = /* @__PURE__ */ new Set();
+  addAll(refs, body, VARIABLE_RE2, true);
+  addAll(refs, body, CONDITIONAL_REF_RE, true);
+  return { refs: [...refs], sets, includes };
+}
+function collect(text, re, fold) {
+  const seen = /* @__PURE__ */ new Set();
+  addAll(seen, text, re, fold);
+  return [...seen];
+}
+function addAll(target, text, re, fold) {
+  for (const m of text.matchAll(re)) {
+    const value = m[1];
+    if (value !== void 0 && value !== "") target.add(fold ? value.toLowerCase() : value);
+  }
+}
+
+// src/internal/errors.ts
+var SpintaxError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SpintaxError";
+  }
+};
+var IncludeResolverError = class extends SpintaxError {
+  constructor(message, options) {
+    super(message);
+    this.name = "IncludeResolverError";
+    if (options && "cause" in options) {
+      this.cause = options.cause;
+    }
+  }
+};
+var AstVersionError = class extends SpintaxError {
+  constructor(message) {
+    super(message);
+    this.name = "AstVersionError";
+  }
+};
+var NotImplementedError = class extends SpintaxError {
+  constructor(what) {
+    super(`${what} is not implemented yet.`);
+    this.name = "NotImplementedError";
+  }
+};
+
+// src/internal/neutralize.ts
+var STRUCTURAL = ["{", "}", "[", "]", "%", "#"];
+var SENTINEL_BASE = 57344;
+var SHIELD = /* @__PURE__ */ new Map();
+var RESTORE = /* @__PURE__ */ new Map();
+STRUCTURAL.forEach((ch, i) => {
+  const sentinel = String.fromCharCode(SENTINEL_BASE + i);
+  SHIELD.set(ch, sentinel);
+  RESTORE.set(sentinel, ch);
+});
+var SHIELD_RE = /[{}[\]%#]/gu;
+var RESTORE_RE = new RegExp(
+  `[${String.fromCharCode(SENTINEL_BASE)}-${String.fromCharCode(SENTINEL_BASE + STRUCTURAL.length - 1)}]`,
+  "gu"
+);
+function neutralize(value) {
+  return value.replace(SHIELD_RE, (ch) => SHIELD.get(ch) ?? ch);
+}
+function safetyRestore(text) {
+  return text.replace(RESTORE_RE, (ch) => RESTORE.get(ch) ?? ch);
+}
+function stripSentinels(text) {
+  return text.replace(RESTORE_RE, "");
+}
+
+// src/internal/render.ts
+var MAX_VARIABLE_DEPTH = 50;
+var INCLUDE_LINE_RE = /^[ \t]*#include[ \t\n\r\f\x0B]+"([^"]+)"[ \t\n\r\f\x0B]*$/gmu;
+function renderAst(ast, ctx) {
+  const vars = buildVars(ast.setDefs, ctx.runtimeContext, ctx.rng);
+  const text = renderNodes(ast.nodes, { vars, rng: ctx.rng, locale: ctx.locale, depth: 0 });
+  return ctx.resolver ? resolveIncludes(text, ctx) : text;
+}
+function resolveIncludes(text, ctx) {
+  INCLUDE_LINE_RE.lastIndex = 0;
+  return text.replace(INCLUDE_LINE_RE, (_m, ref) => {
+    if (ctx.includeStack.includes(ref) || ctx.includeStack.length >= ctx.maxDepth) return "";
+    let included;
+    try {
+      included = ctx.resolver(ref);
+    } catch (cause) {
+      throw new IncludeResolverError(`includeResolver threw for "${ref}"`, { cause });
+    }
+    if (included === null) return "";
+    return renderAst(parseTemplate(stripSentinels(included)), {
+      ...ctx,
+      runtimeContext: ctx.runtimeContext,
+      // child inherits runtime, not parent #set
+      includeStack: [...ctx.includeStack, ref]
+    });
+  });
+}
+function buildVars(setDefs, context, rng) {
+  const vars = {};
+  for (const [name, value] of Object.entries(setDefs)) {
+    vars[name] = collapseSetValue(value, rng);
+  }
+  for (const [name, value] of Object.entries(context)) {
+    vars[name.toLowerCase()] = value;
+  }
+  return vars;
+}
+function collapseSetValue(value, rng) {
+  if (!value.includes("{")) return value;
+  if (value.includes("{?") || value.includes("{plural ")) return value;
+  return resolveEnumerationsString(value, rng);
+}
+function resolveEnumerationsString(text, rng) {
+  let out = text;
+  for (let guard = 0; guard < 1e3; guard += 1) {
+    let changed = false;
+    out = out.replace(/\{([^{}]*)\}/gu, (_m, inner) => {
+      changed = true;
+      const options = splitTopLevelPipes(inner);
+      return options.length === 0 ? "" : options[randomInt(rng, 0, options.length - 1)] ?? "";
+    });
+    if (!changed) break;
+  }
+  return out;
+}
+function renderNodes(nodes, opts) {
+  let out = "";
+  for (const node of nodes) out += renderNode(node, opts);
+  return out;
+}
+function renderNode(node, opts) {
+  switch (node.type) {
+    case "literal":
+      return node.value;
+    case "variable":
+      return resolveVariable(node.name, opts);
+    case "enumeration":
+      return renderEnumeration(node.options, opts);
+    case "permutation":
+      return renderPermutation(node, opts);
+    case "conditional":
+      return renderConditional(node, opts);
+    case "plural":
+      return renderPlural(node, opts);
+  }
+}
+function randomInt(rng, min, max) {
+  return min === max ? min : rng(min, max);
+}
+function resolveVariable(name, opts) {
+  const value = opts.vars[name.toLowerCase()];
+  if (value === void 0) return `%${name}%`;
+  if (opts.depth >= MAX_VARIABLE_DEPTH || !/[{[%]/u.test(value)) return value;
+  return renderNodes(parseSequence(value), { ...opts, depth: opts.depth + 1 });
+}
+function expandVarsOnly(text, opts) {
+  let out = text;
+  for (let i = 0; i < MAX_VARIABLE_DEPTH; i += 1) {
+    let changed = false;
+    out = out.replace(/%(\w+)%/gu, (m, name) => {
+      const value = opts.vars[name.toLowerCase()];
+      if (value === void 0) return m;
+      changed = true;
+      return value;
+    });
+    if (!changed) break;
+  }
+  return out;
+}
+function renderConditional(node, opts) {
+  const value = opts.vars[node.name.toLowerCase()];
+  const baseTruthy = value !== void 0 && /\S/u.test(value);
+  const truthy = node.inverted ? !baseTruthy : baseTruthy;
+  return renderNodes(truthy ? node.then : node.else, opts);
+}
+function renderPlural(node, opts) {
+  const countRaw = expandVarsOnly(node.countRaw, opts);
+  const formsRaw = expandVarsOnly(node.formsRaw, opts);
+  if (/[{}[\]]/u.test(formsRaw)) return fullwidthVerbatim(countRaw, formsRaw);
+  const count = phpTrim2(countRaw);
+  if (!/^-?\d+$/u.test(count)) return "";
+  const base = normalizeBaseLang(opts.locale);
+  const forms = formsRaw.split("|").map((f) => phpTrim2(f));
+  if (forms.length !== pluralArity(base)) return fullwidthVerbatim(countRaw, formsRaw);
+  const picked = pluralFor(base, Number.parseInt(count, 10), forms);
+  return renderNodes(parseSequence(picked), opts);
+}
+function fullwidthVerbatim(countRaw, formsRaw) {
+  return `{plural ${countRaw}:${formsRaw}}`.replace(/\{/gu, "\uFF5B").replace(/\}/gu, "\uFF5D");
+}
+function renderEnumeration(options, opts) {
+  if (options.length === 0) return "";
+  const picked = options[randomInt(opts.rng, 0, options.length - 1)];
+  return picked ? renderNodes(picked, opts) : "";
+}
+function renderPermutation(node, opts) {
+  const elements = node.options.map((o) => ({
+    text: renderNodes(o.nodes, opts),
+    sep: o.separator
+  }));
+  const total = elements.length;
+  if (total === 0) return "";
+  const { config } = node;
+  const hasMin = config.minsize !== null;
+  const hasMax = config.maxsize !== null;
+  let min;
+  let max;
+  if (hasMin && hasMax) {
+    min = config.minsize;
+    max = config.maxsize;
+  } else if (hasMin) {
+    min = config.minsize;
+    max = total;
+  } else if (hasMax) {
+    min = 1;
+    max = config.maxsize;
+  } else {
+    min = total;
+    max = total;
+  }
+  min = Math.max(1, Math.min(min, total));
+  max = Math.max(min, Math.min(max, total));
+  const pick = randomInt(opts.rng, min, max);
+  shuffle(elements, opts.rng);
+  return joinWithSeparators(elements.slice(0, pick), config.sep, config.lastsep ?? config.sep);
+}
+function shuffle(arr, rng) {
+  for (let i = arr.length - 1; i > 0; i -= 1) {
+    const j = randomInt(rng, 0, i);
+    const tmp = arr[i];
+    arr[i] = arr[j];
+    arr[j] = tmp;
+  }
+}
+function joinWithSeparators(elements, globalSep, globalLastsep) {
+  const count = elements.length;
+  if (count === 0) return "";
+  if (count === 1) return elements[0].text;
+  let out = elements[0].text;
+  for (let i = 1; i < count; i += 1) {
+    const el = elements[i];
+    const sep = el.sep ?? (i === count - 1 ? globalLastsep : globalSep);
+    out += padSeparator(sep) + el.text;
+  }
+  return out;
+}
+function padSeparator(sep) {
+  const trimmed = phpTrim2(sep);
+  if (trimmed === "") return sep;
+  if (/^\p{L}+$/u.test(trimmed)) return ` ${trimmed} `;
+  return sep;
+}
+function splitTopLevelPipes(inner) {
+  const parts = [];
+  let brace = 0;
+  let bracket = 0;
+  let cur = "";
+  for (const ch of inner) {
+    if (ch === "{") brace += 1;
+    else if (ch === "}") brace -= 1;
+    else if (ch === "[") bracket += 1;
+    else if (ch === "]") bracket -= 1;
+    if (ch === "|" && brace === 0 && bracket === 0) {
+      parts.push(cur);
+      cur = "";
+    } else {
+      cur += ch;
+    }
+  }
+  parts.push(cur);
+  return parts;
+}
+var PHP_LTRIM_RE2 = /^[ \t\n\r\0\x0B]+/u;
+var PHP_RTRIM_RE2 = /[ \t\n\r\0\x0B]+$/u;
+function phpTrim2(s) {
+  return s.replace(PHP_LTRIM_RE2, "").replace(PHP_RTRIM_RE2, "");
+}
+
+// src/internal/postprocess.ts
+var SINGLE_ABBREVS = [
+  // Russian editorial / address / unit shorthands.
+  "\u0441\u043E\u0446",
+  "\u044D\u043B",
+  "\u0441\u043C",
+  "\u0441\u0440",
+  "\u0441\u0442",
+  "\u0443\u043B",
+  "\u043F\u0440",
+  "\u043F\u0435\u0440",
+  "\u0433",
+  "\u0440",
+  "\u0440\u0443\u0431",
+  "\u043A\u043E\u043F",
+  "\u0442\u044B\u0441",
+  "\u043C\u043B\u043D",
+  "\u043C\u043B\u0440\u0434",
+  "\u0442\u0440\u043B\u043D",
+  "\u0434\u043E\u043F",
+  "\u043D\u0430\u043F\u0440",
+  "\u043F\u0440\u0438\u043C",
+  "\u0438\u0437\u0434",
+  "\u043E\u0431\u043B",
+  "\u0440\u0435\u0441\u043F",
+  "\u0441\u0442\u0440",
+  "\u0442\u0430\u0431\u043B",
+  "\u0440\u0438\u0441",
+  "\u043C\u0438\u043D",
+  "\u043C\u0430\u043A\u0441",
+  "\u0442\u0435\u043B",
+  "\u0444\u0430\u043A\u0441",
+  // English titles / business suffixes / editorial.
+  "etc",
+  "vs",
+  "Mr",
+  "Mrs",
+  "Ms",
+  "Dr",
+  "Prof",
+  "Sr",
+  "Jr",
+  "Inc",
+  "Ltd",
+  "Co",
+  "Corp",
+  "No",
+  "St",
+  "Ave",
+  "Blvd"
+];
+var WS = " \\t\\r\\n\\f\\x0B";
+var S = `[${WS}]`;
+var DOMAIN_PART = "(?:(?:(?:xn--)?[\\p{L}\\p{N}]+(?:-[\\p{L}\\p{N}]+)*)\\.)+(?:xn--[a-z0-9\\-]{2,59}|[\\p{L}][\\p{L}\\p{N}-]{1,62})";
+var URL_RE = new RegExp(`(?:https?|ftp):\\/\\/[^${WS}<>"')\\]]+`, "giu");
+var EMAIL_RE = new RegExp(`[a-z0-9._%+\\-]+@${DOMAIN_PART}\\b`, "giu");
+var DOMAIN_RE = new RegExp(`\\b${DOMAIN_PART}\\b`, "giu");
+var DECIMAL_RE = /\b\d+\.\d+\b/gu;
+var MULTI_ABBR_RE = new RegExp(`\\b(?:\\p{L}{1,2}\\.${S}*){2,}`, "gu");
+var SINGLE_ABBR_RE = new RegExp(`(?<![\\p{L}\\p{N}])(?:${SINGLE_ABBREVS.join("|")})\\.(?=${S}|$|<)`, "giu");
+var TRAILING_PUNCT_RE = /([.,;:!]+)$/u;
+var SPACE_BEFORE_PUNCT_RE = new RegExp(`${S}+([,;:!?.])`, "gu");
+var SPACE_AFTER_COMMA_RE = new RegExp(`([,;:])(?!\\d)(?!${S}|$|<)`, "gu");
+var SPACE_AFTER_SENTENCE_RE = new RegExp(`([.!?])(?!\\d)(?!${S}|$|<)`, "gu");
+var CAP_FIRST_RE = new RegExp(`^(${S}*(?:<[^>]+>${S}*)*)(\\p{Ll})`, "u");
+var CAP_AFTER_SENTENCE_RE = new RegExp(`([.!?\u2026])(${S}*(?:<\\/?[^>]+>${S}*)*)(\\p{Ll})`, "gu");
+var CAP_AFTER_BLOCK_RE = new RegExp(`(<\\/?(?:p|h[1-6]|li|blockquote|div|td|th)[^>]*>${S}*)(\\p{Ll})`, "giu");
+var CAP_AFTER_BREAK_RE = new RegExp(`(\\n${S}*)(\\p{Ll})`, "gu");
+var up = (ch) => ch.toUpperCase();
+function postProcess(input) {
+  const placeholders = /* @__PURE__ */ new Map();
+  let counter = 0;
+  const store = (value, prefix) => {
+    const key = `\0${prefix}_${counter}\0`;
+    placeholders.set(key, value);
+    counter += 1;
+    return key;
+  };
+  const storeWithTrailingPunct = (value, prefix) => {
+    const m = TRAILING_PUNCT_RE.exec(value);
+    if (m) {
+      const suffix = m[1] ?? "";
+      const body = value.slice(0, value.length - suffix.length);
+      return body === "" ? suffix : store(body, prefix) + suffix;
+    }
+    return store(value, prefix);
+  };
+  let text = input;
+  text = text.replace(URL_RE, (m) => storeWithTrailingPunct(m, "URL"));
+  text = text.replace(EMAIL_RE, (m) => store(m, "EMAIL"));
+  text = text.replace(DOMAIN_RE, (m) => store(m, "DOM"));
+  text = text.replace(DECIMAL_RE, (m) => store(m, "NUM"));
+  text = text.replace(MULTI_ABBR_RE, (m) => store(m, "ABBR"));
+  text = text.replace(SINGLE_ABBR_RE, (m) => store(m, "ABBR"));
+  text = text.replace(/[ \t]{2,}/gu, " ");
+  text = text.replace(SPACE_BEFORE_PUNCT_RE, "$1");
+  text = text.replace(SPACE_AFTER_COMMA_RE, "$1 ");
+  text = text.replace(SPACE_AFTER_SENTENCE_RE, "$1 ");
+  text = text.replace(CAP_FIRST_RE, (_m, lead, ch) => lead + up(ch));
+  text = text.replace(CAP_AFTER_SENTENCE_RE, (_m, p, gap, ch) => p + gap + up(ch));
+  text = text.replace(CAP_AFTER_BLOCK_RE, (_m, tag, ch) => tag + up(ch));
+  text = text.replace(CAP_AFTER_BREAK_RE, (_m, br, ch) => br + up(ch));
+  for (const [key, value] of placeholders) {
+    text = text.split(key).join(value);
+  }
+  return text.trim();
+}
+
+// src/internal/pipeline.ts
+var DEFAULT_MAX_DEPTH = 20;
+function renderWith(input, rng, opts = {}) {
+  const ctx = {
+    runtimeContext: opts.context ?? {},
+    rng,
+    locale: opts.locale ?? "",
+    resolver: opts.includeResolver,
+    maxDepth: opts.maxDepth ?? DEFAULT_MAX_DEPTH,
+    includeStack: []
+  };
+  const ast = resolveAst(typeof input === "string" ? stripSentinels(input) : input);
+  let out = renderAst(ast, ctx);
+  if (opts.postProcess !== false) out = postProcess(out);
+  return safetyRestore(out);
+}
+function resolveAst(input) {
+  if (typeof input === "string") return parseTemplate(input);
+  if (isParsedAst(input)) return input;
+  throw new AstVersionError("Ast was not produced by this engine version.");
+}
+
+// src/internal/rng.ts
+function makeRng(seed) {
+  const next = seed === void 0 ? Math.random : mulberry32(typeof seed === "number" ? seed >>> 0 : hashString(seed));
+  return (min, max) => min + Math.floor(next() * (max - min + 1));
+}
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function hashString(s) {
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i += 1) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+
+// src/index.ts
+function parse(src) {
+  return parseTemplate(src);
+}
+function render(input, opts = {}) {
+  return renderWith(input, makeRng(opts.seed), opts);
+}
+function validate(input, opts = {}) {
+  return validateTemplate(resolveSource(input), opts);
+}
+function resolveSource(input) {
+  if (typeof input === "string") return input;
+  if (isParsedAst(input)) return input.source;
+  throw new AstVersionError("Ast was not produced by this engine version.");
+}
+function extract(input) {
+  return extractFromSource(resolveSource(input));
+}
+function analyze(input, opts = {}) {
+  const ast = resolveAst2(input);
+  const extracted = extractFromSource(ast.source);
+  return {
+    ...extracted,
+    diagnostics: validateTemplate(ast.source, opts),
+    constructs: countConstructs(ast, extracted.includes.length)
+  };
+}
+function resolveAst2(input) {
+  if (typeof input === "string") return parseTemplate(input);
+  if (isParsedAst(input)) return input;
+  throw new AstVersionError("Ast was not produced by this engine version.");
+}
+function countConstructs(ast, includeCount) {
+  const counts = {
+    enumeration: 0,
+    permutation: 0,
+    variable: 0,
+    conditional: 0,
+    plural: 0
+  };
+  walk(ast.nodes, (n) => {
+    if (n.type in counts) counts[n.type] = (counts[n.type] ?? 0) + 1;
+  });
+  counts.set = Object.keys(ast.setDefs).length;
+  counts.include = includeCount;
+  return counts;
+}
+function neutralize2(value) {
+  return neutralize(value);
+}
+
+exports.AstVersionError = AstVersionError;
+exports.DEFAULT_MAX_DEPTH = DEFAULT_MAX_DEPTH;
+exports.IncludeResolverError = IncludeResolverError;
+exports.NotImplementedError = NotImplementedError;
+exports.SpintaxError = SpintaxError;
+exports.analyze = analyze;
+exports.extract = extract;
+exports.neutralize = neutralize2;
+exports.parse = parse;
+exports.render = render;
+exports.validate = validate;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map