@spintax/core 0.6.1 → 0.8.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/internal/ast.ts
-var AST_VERSION = 2;
+var AST_VERSION = 4;
 function walk(nodes, visit) {
   const stack = [{ list: nodes, i: 0 }];
   while (stack.length > 0) {
@@ -34,6 +34,15 @@ function isParsedAst(value) {
   return typeof value === "object" && value !== null && value.astVersion === AST_VERSION && typeof value.source === "string" && Array.isArray(value.nodes);
 }
 
+// src/internal/name-map.ts
+function nameMap(...sources) {
+  const map = /* @__PURE__ */ Object.create(null);
+  for (const source of sources) {
+    for (const name of Object.keys(source)) map[name] = source[name];
+  }
+  return map;
+}
+
 // src/internal/neutralize.ts
 var STRUCTURAL = ["{", "}", "[", "]", "%", "#"];
 var SENTINEL_BASE = 57344;
@@ -59,18 +68,300 @@ function stripSentinels(text) {
   return text.replace(RESTORE_RE, "");
 }
 
-// src/internal/parser.ts
-var VARIABLE_RE = /^%(\w+)%/;
-var DIRECTIVE_RE = /^[ \t]*#(set|def)[ \t]+%(\w+)%[ \t]*=[ \t]*(.*?)[ \t]*\r?$/gmu;
+// src/internal/pairs.ts
+var BRACE_OPEN = 123;
+var BRACE_CLOSE = 125;
+var BRACKET_OPEN = 91;
+var BRACKET_CLOSE = 93;
+function matchPairs(text, open, close) {
+  const pairs = new Int32Array(text.length).fill(-1);
+  const stack = [];
+  for (let i = 0; i < text.length; i += 1) {
+    const code = text.charCodeAt(i);
+    if (code === open) {
+      stack.push(i);
+    } else if (code === close) {
+      const opener = stack.pop();
+      if (opener !== void 0) pairs[opener] = i;
+    }
+  }
+  return pairs;
+}
+function matchAnyPairs(text) {
+  const pairs = new Int32Array(text.length).fill(-1);
+  const stack = [];
+  for (let i = 0; i < text.length; i += 1) {
+    const code = text.charCodeAt(i);
+    if (code === BRACE_OPEN || code === BRACKET_OPEN) {
+      stack.push(i);
+    } else if (code === BRACE_CLOSE || code === BRACKET_CLOSE) {
+      const opener = stack.pop();
+      if (opener !== void 0) pairs[opener] = i;
+    }
+  }
+  return pairs;
+}
+
+// src/internal/text-index.ts
+var PIPE = 124;
+var COLON = 58;
+var QUOTE = 34;
+var LT = 60;
+var GT = 62;
+var BANG = 33;
+var QUESTION = 63;
 var CONDITIONAL_NAME_RE = /[A-Za-z_]\w*/y;
+var REFERENCE_SCAN_RE = /%(\w+)%/gu;
+var CLOSING_TAG_RE = /<\/([a-z][a-z0-9-]*)[ \t\n\x0B\f\r]*>/giu;
+function foldTagName(name) {
+  return name.toLowerCase().split(LONG_S).join("s");
+}
+var LONG_S = String.fromCharCode(383);
+var rereadSpans = /* @__PURE__ */ new WeakMap();
+function lowerBound(list, x) {
+  let lo = 0;
+  let hi = list.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (list[mid] < x) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+var TextIndex = class {
+  text;
+  braces = null;
+  brackets = null;
+  any = null;
+  pipeBrace = null;
+  pipeBracket = null;
+  pipesByDepth = null;
+  colons = null;
+  quotes = null;
+  gtByQuoteParity = null;
+  closingTags = null;
+  angles = null;
+  heads = null;
+  headCloseMin = null;
+  headTreeSize = 0;
+  definedReferences = /* @__PURE__ */ new WeakMap();
+  constructor(text) {
+    this.text = text;
+  }
+  /**
+   * The closer matching the `{` or `[` at `i` within a span ending at `end`, or -1.
+   *
+   * The table pairs the whole text, and a span agrees with it: an opener inside a span is closed there
+   * exactly when the closer the whole text pairs it with lies inside too, because every opener pushed
+   * after it is pushed after the span begins.
+   */
+  closerWithin(i, end) {
+    const table = this.text.charCodeAt(i) === BRACE_OPEN ? this.braces ??= matchPairs(this.text, BRACE_OPEN, BRACE_CLOSE) : this.brackets ??= matchPairs(this.text, BRACKET_OPEN, BRACKET_CLOSE);
+    const close = table[i];
+    return close !== -1 && close < end ? close : -1;
+  }
+  /** {@link matchAnyPairs} of the text: one stack for both bracket kinds, as a clamped depth counts. */
+  anyPairs() {
+    return this.any ??= matchAnyPairs(this.text);
+  }
+  /**
+   * The pipes of `[start, end)` that `splitTopLevel` splits at, in order.
+   *
+   * Its two counters are signed and start at zero, so a pipe at `p` splits exactly when the text before
+   * it holds as many `{` as `}` and as many `[` as `]` counted from `start` — when both running totals
+   * over the whole text read the same at `p` as at `start`. The pipes are grouped by those two totals
+   * once, and a span takes the group of its start.
+   */
+  topLevelPipes(start, end) {
+    if (this.pipesByDepth === null) this.indexPipes();
+    const braceDepth = this.pipeBrace;
+    const bracketDepth = this.pipeBracket;
+    const group = this.pipesByDepth.get(braceDepth[start])?.get(bracketDepth[start]);
+    if (group === void 0) return [];
+    const out = [];
+    for (let k = lowerBound(group, start); k < group.length && group[k] < end; k += 1) {
+      out.push(group[k]);
+    }
+    return out;
+  }
+  indexPipes() {
+    const n = this.text.length;
+    const braceDepth = new Int32Array(n + 1);
+    const bracketDepth = new Int32Array(n + 1);
+    const groups = /* @__PURE__ */ new Map();
+    let brace = 0;
+    let bracket = 0;
+    for (let i = 0; i < n; i += 1) {
+      braceDepth[i] = brace;
+      bracketDepth[i] = bracket;
+      const code = this.text.charCodeAt(i);
+      if (code === BRACE_OPEN) brace += 1;
+      else if (code === BRACE_CLOSE) brace -= 1;
+      else if (code === BRACKET_OPEN) bracket += 1;
+      else if (code === BRACKET_CLOSE) bracket -= 1;
+      else if (code === PIPE) {
+        let byBracket = groups.get(brace);
+        if (byBracket === void 0) groups.set(brace, byBracket = /* @__PURE__ */ new Map());
+        const list = byBracket.get(bracket);
+        if (list === void 0) byBracket.set(bracket, [i]);
+        else list.push(i);
+      }
+    }
+    braceDepth[n] = brace;
+    bracketDepth[n] = bracket;
+    this.pipeBrace = braceDepth;
+    this.pipeBracket = bracketDepth;
+    this.pipesByDepth = groups;
+  }
+  /** The first `:` in `[from, end)`, or -1. */
+  colonWithin(from, end) {
+    const colons = this.colons ??= this.positionsOf(COLON);
+    const k = lowerBound(colons, from);
+    return k < colons.length && colons[k] < end ? colons[k] : -1;
+  }
+  /**
+   * The `>` that ends a `<config>` whose `<` is at `lt`, before `end`, or -1: the first one with an even
+   * number of `"` between the `<` and it — the quote toggle `findConfigEnd` keeps, as a parity.
+   */
+  configEnd(lt, end) {
+    const quotes = this.quotes ??= this.positionsOf(QUOTE);
+    if (this.gtByQuoteParity === null) {
+      const even = [];
+      const odd = [];
+      let seen = 0;
+      for (let i = 0; i < this.text.length; i += 1) {
+        const code = this.text.charCodeAt(i);
+        if (code === QUOTE) seen += 1;
+        else if (code === GT) (seen % 2 === 0 ? even : odd).push(i);
+      }
+      this.gtByQuoteParity = [even, odd];
+    }
+    const parity = lowerBound(quotes, lt + 1) % 2;
+    const candidates = this.gtByQuoteParity[parity];
+    const k = lowerBound(candidates, lt + 1);
+    return k < candidates.length && candidates[k] < end ? candidates[k] : -1;
+  }
+  /**
+   * Does a closing tag of `tagName` lie wholly inside `[from, end)`? Closing tags cannot overlap — each
+   * starts with the only `<` it holds — so one scan of the whole text finds every one a scan of the span
+   * would, and the first one starting at or after `from` is the one that ends soonest.
+   */
+  hasClosingTag(tagName, from, end) {
+    if (this.closingTags === null) {
+      const tags = /* @__PURE__ */ new Map();
+      for (const m of this.text.matchAll(CLOSING_TAG_RE)) {
+        const name = foldTagName(m[1] ?? "");
+        let entry2 = tags.get(name);
+        if (entry2 === void 0) tags.set(name, entry2 = { starts: [], ends: [] });
+        entry2.starts.push(m.index ?? 0);
+        entry2.ends.push((m.index ?? 0) + m[0].length);
+      }
+      this.closingTags = tags;
+    }
+    const entry = this.closingTags.get(tagName);
+    if (entry === void 0) return false;
+    const k = lowerBound(entry.starts, from);
+    return k < entry.starts.length && entry.ends[k] <= end;
+  }
+  /** The last `<` or `>` in `[floor, at]`, or -1. */
+  lastAngleWithin(floor, at) {
+    if (this.angles === null) {
+      const angles = [];
+      for (let i = 0; i < this.text.length; i += 1) {
+        const code = this.text.charCodeAt(i);
+        if (code === LT || code === GT) angles.push(i);
+      }
+      this.angles = angles;
+    }
+    const k = lowerBound(this.angles, at + 1) - 1;
+    return k >= 0 && this.angles[k] >= floor ? this.angles[k] : -1;
+  }
+  /**
+   * Would the renderer's conditional pass over `[start, end)` resolve anything? Exactly when a `{?` in
+   * the span opens a well-formed head and its brace closes inside the span: the pass reaches the first
+   * such one in order, because every `{?` before it is one it steps over.
+   */
+  hasConditionalWithin(start, end) {
+    if (this.heads === null) this.indexHeads();
+    const heads = this.heads;
+    let lo = lowerBound(heads, start) + this.headTreeSize;
+    let hi = lowerBound(heads, end) + this.headTreeSize;
+    const tree = this.headCloseMin;
+    let min = Infinity;
+    while (lo < hi) {
+      if (lo & 1) min = Math.min(min, tree[lo++]);
+      if (hi & 1) min = Math.min(min, tree[--hi]);
+      lo >>= 1;
+      hi >>= 1;
+    }
+    return min < end;
+  }
+  indexHeads() {
+    const heads = [];
+    const closes = [];
+    const braces = this.braces ??= matchPairs(this.text, BRACE_OPEN, BRACE_CLOSE);
+    for (let at = this.text.indexOf("{?"); at !== -1; at = this.text.indexOf("{?", at + 1)) {
+      let p = at + 2;
+      if (this.text.charCodeAt(p) === BANG) p += 1;
+      CONDITIONAL_NAME_RE.lastIndex = p;
+      const name = CONDITIONAL_NAME_RE.exec(this.text);
+      if (name === null || this.text.charCodeAt(p + name[0].length) !== QUESTION) continue;
+      heads.push(at);
+      closes.push(braces[at]);
+    }
+    let size = 1;
+    while (size < heads.length) size *= 2;
+    const tree = new Float64Array(2 * size).fill(Infinity);
+    closes.forEach((close, k) => {
+      tree[size + k] = close === -1 ? Infinity : close;
+    });
+    for (let k = size - 1; k >= 1; k -= 1) tree[k] = Math.min(tree[2 * k], tree[2 * k + 1]);
+    this.heads = heads;
+    this.headCloseMin = tree;
+    this.headTreeSize = size;
+  }
+  /**
+   * Would expansion substitute anything in `[start, end)` — is a reference there to a name `vars`
+   * defines? A reference cannot straddle a span of a construct's content (a bracket bounds it on both
+   * sides), so the references one scan of the whole text finds are the ones a scan of the span would.
+   */
+  hasDefinedReferenceWithin(start, end, vars) {
+    let positions = this.definedReferences.get(vars);
+    if (positions === void 0) {
+      positions = [];
+      for (const m of this.text.matchAll(REFERENCE_SCAN_RE)) {
+        if (vars[(m[1] ?? "").toLowerCase()] !== void 0) positions.push(m.index ?? 0);
+      }
+      this.definedReferences.set(vars, positions);
+    }
+    const k = lowerBound(positions, start);
+    return k < positions.length && positions[k] < end;
+  }
+  positionsOf(code) {
+    const ch = String.fromCharCode(code);
+    const out = [];
+    for (let i = this.text.indexOf(ch); i !== -1; i = this.text.indexOf(ch, i + 1)) out.push(i);
+    return out;
+  }
+};
+
+// src/internal/parser.ts
+var VARIABLE_RE = /%(\w+)%/y;
+var PERCENT = 37;
+var QUESTION2 = 63;
+var PIPE2 = 124;
+var LT2 = 60;
+var GT2 = 62;
+var DIRECTIVE_RE = /^[ \t]*#(set|def)[ \t]+%(\w+)%[ \t]*=[ \t]*((?:.*[^ \t\n\r\u2028\u2029])?)[ \t]*\r?$/gmu;
+var CONDITIONAL_NAME_RE2 = /[A-Za-z_]\w*/y;
 var PLURAL_PREFIX = "plural ";
 function parseTemplate(src) {
   const { body, setDefs, defDefs } = extractDirectives(stripComments(stripSentinels(src)));
   return { astVersion: AST_VERSION, source: src, setDefs, defDefs, nodes: parseSequence(body) };
 }
 function extractDirectives(text) {
-  const setDefs = {};
-  const defDefs = {};
+  const setDefs = nameMap();
+  const defDefs = nameMap();
   const occurrences = [];
   let cursorOffset = 0;
   let cursorLine = 1;
@@ -100,16 +391,36 @@ function extractDirectives(text) {
   return { body: stripped.replace(/\n{3,}/gu, "\n\n"), setDefs, defDefs, occurrences };
 }
 function stripComments(text) {
-  return text.replace(/\/#[\s\S]*?#\//g, "");
+  let out = "";
+  let from = 0;
+  for (; ; ) {
+    const open = text.indexOf("/#", from);
+    if (open === -1) break;
+    const close = text.indexOf("#/", open + 2);
+    if (close === -1) break;
+    out += text.slice(from, open);
+    from = close + 2;
+  }
+  return from === 0 ? text : out + text.slice(from);
 }
 function parseSequence(text) {
-  const frame = (t) => ({ text: t, i: 0, literal: "", nodes: [], plan: null, parts: [] });
-  const stack = [frame(text)];
+  const index = new TextIndex(text);
+  const frame = (start, end) => ({
+    start,
+    end,
+    i: start,
+    literal: start,
+    nodes: [],
+    plan: null,
+    parts: []
+  });
+  const stack = [frame(0, text.length)];
   while (stack.length > 0) {
     const f = stack[stack.length - 1];
     if (f.plan !== null) {
-      if (f.parts.length < f.plan.texts.length) {
-        stack.push(frame(f.plan.texts[f.parts.length]));
+      if (f.parts.length < f.plan.spans.length) {
+        const span2 = f.plan.spans[f.parts.length];
+        stack.push(frame(span2[0], span2[1]));
         continue;
       }
       f.nodes.push(f.plan.build(f.parts));
@@ -117,39 +428,35 @@ function parseSequence(text) {
       f.parts = [];
       continue;
     }
-    const flushLiteral = () => {
-      if (f.literal !== "") {
-        f.nodes.push({ type: "literal", value: f.literal });
-        f.literal = "";
-      }
+    const flushLiteral = (to) => {
+      if (to > f.literal) f.nodes.push({ type: "literal", value: text.slice(f.literal, to) });
     };
     let planned = null;
-    while (f.i < f.text.length && planned === null) {
-      const ch = f.text.charAt(f.i);
-      if (ch === "{" || ch === "[") {
-        const close = ch === "{" ? "}" : "]";
-        const end = findMatchingClose(f.text, f.i, ch, close);
-        if (end === -1) {
-          f.literal += ch;
+    while (f.i < f.end && planned === null) {
+      const code = text.charCodeAt(f.i);
+      if (code === BRACE_OPEN || code === BRACKET_OPEN) {
+        const close = index.closerWithin(f.i, f.end);
+        if (close === -1) {
           f.i += 1;
           continue;
         }
-        const inner = f.text.slice(f.i + 1, end);
-        flushLiteral();
-        planned = ch === "{" ? planBraceConstruct(inner) : planPermutation(inner);
-        f.i = end + 1;
+        flushLiteral(f.i);
+        planned = code === BRACE_OPEN ? planBraceConstruct(index, f.i + 1, close) : planPermutation(index, f.i + 1, close);
+        f.i = close + 1;
+        f.literal = f.i;
         continue;
       }
-      if (ch === "%") {
-        const name = VARIABLE_RE.exec(f.text.slice(f.i))?.[1];
-        if (name !== void 0) {
-          flushLiteral();
-          f.nodes.push({ type: "variable", name });
-          f.i += name.length + 2;
+      if (code === PERCENT) {
+        VARIABLE_RE.lastIndex = f.i;
+        const m = VARIABLE_RE.exec(text);
+        if (m !== null && VARIABLE_RE.lastIndex <= f.end) {
+          flushLiteral(f.i);
+          f.nodes.push({ type: "variable", name: m[1] });
+          f.i = VARIABLE_RE.lastIndex;
+          f.literal = f.i;
           continue;
         }
       }
-      f.literal += ch;
       f.i += 1;
     }
     if (planned !== null) {
@@ -157,7 +464,7 @@ function parseSequence(text) {
       else f.plan = planned;
       continue;
     }
-    flushLiteral();
+    flushLiteral(f.end);
     stack.pop();
     const parent = stack[stack.length - 1];
     if (parent !== void 0) parent.parts.push(f.nodes);
@@ -165,104 +472,130 @@ function parseSequence(text) {
   }
   return [];
 }
-function planBraceConstruct(content) {
-  if (content.charAt(0) === "?") {
-    const parts = splitConditional(content);
-    if (parts !== null) {
+function spansBetween(start, end, pipes) {
+  const spans = [];
+  let from = start;
+  for (const pipe of pipes) {
+    spans.push([from, pipe]);
+    from = pipe + 1;
+  }
+  spans.push([from, end]);
+  return spans;
+}
+function planBraceConstruct(index, start, end) {
+  const { text } = index;
+  if (start < end && text.charCodeAt(start) === QUESTION2) {
+    const head = recognizeConditional(text, start, end, index.anyPairs());
+    if (head !== null) {
+      const then = [head.bodyStart, head.sepIndex < 0 ? end : head.sepIndex];
+      const otherwise = head.sepIndex < 0 ? [end, end] : [head.sepIndex + 1, end];
       return {
-        texts: [parts.thenRaw, parts.elseRaw],
+        spans: [then, otherwise],
         build: (children) => ({
           type: "conditional",
-          name: parts.name,
-          inverted: parts.inverted,
+          name: head.name,
+          inverted: head.inverted,
           then: children[0] ?? [],
           else: children[1] ?? []
         })
       };
     }
-  } else if (content.startsWith(PLURAL_PREFIX) && content.slice(PLURAL_PREFIX.length).includes(":")) {
-    return { node: parsePlural(content.slice(PLURAL_PREFIX.length)) };
+  } else if (end - start >= PLURAL_PREFIX.length && text.startsWith(PLURAL_PREFIX, start)) {
+    const colon = index.colonWithin(start + PLURAL_PREFIX.length, end);
+    if (colon !== -1) {
+      return {
+        node: {
+          type: "plural",
+          countRaw: text.slice(start + PLURAL_PREFIX.length, colon),
+          formsRaw: text.slice(colon + 1, end)
+        }
+      };
+    }
   }
   return {
-    texts: splitTopLevel(content),
-    build: (children) => ({ type: "enumeration", options: children })
+    spans: spansBetween(start, end, index.topLevelPipes(start, end)),
+    build: (children) => {
+      if (!needsTextualReread(children)) return { type: "enumeration", options: children };
+      const node = { type: "enumeration", options: children, raw: text.slice(start, end) };
+      rereadSpans.set(node, { index, start, end });
+      return node;
+    }
   };
 }
-function planPermutation(rawInner) {
-  const { config, content } = extractPermutationConfig(rawInner);
-  const { texts, separators } = permutationElements(splitTopLevel(content));
+function needsTextualReread(lists) {
+  return lists.some((list) => list.some((node) => node.type === "variable" || node.type === "conditional"));
+}
+var REFERENCE_RE = /%\w+%/u;
+function holdsConditional(text) {
+  if (!text.includes("{?")) return false;
+  const opens = [];
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text.charAt(i);
+    if (ch === "{") {
+      opens.push(i);
+    } else if (ch === "}") {
+      const open = opens.pop();
+      if (open !== void 0 && text.charAt(open + 1) === "?" && recognizeConditional(text, open + 1, i) !== null) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+var holdsTextForReread = (text) => REFERENCE_RE.test(text) || holdsConditional(text);
+function planPermutation(index, start, end) {
+  const { text } = index;
+  const { config, contentStart } = extractPermutationConfig(index, start, end);
+  const { spans, separators } = permutationElements(index, spansBetween(contentStart, end, index.topLevelPipes(contentStart, end)));
+  const header = text.slice(start, contentStart);
+  const textNeedsReread = holdsTextForReread(header) || separators.some((sep) => sep !== null && holdsTextForReread(sep));
   return {
-    texts,
-    build: (children) => ({
-      type: "permutation",
-      config,
-      options: children.map((nodes, i) => ({ nodes, separator: separators[i] ?? null }))
-    })
+    spans,
+    build: (children) => {
+      const options = children.map((nodes, i) => ({ nodes, separator: separators[i] ?? null }));
+      if (!textNeedsReread && !needsTextualReread(children)) return { type: "permutation", config, options };
+      const node = { type: "permutation", config, options, raw: text.slice(start, end) };
+      rereadSpans.set(node, { index, start, end });
+      return node;
+    }
   };
 }
-function recognizeConditional(text, contentStart, contentEnd) {
+function recognizeConditional(text, contentStart, contentEnd, anyPairs) {
   let p = contentStart + 1;
   let inverted = false;
   if (text.charAt(p) === "!") {
     inverted = true;
     p += 1;
   }
-  CONDITIONAL_NAME_RE.lastIndex = p;
-  const name = CONDITIONAL_NAME_RE.exec(text)?.[0];
+  CONDITIONAL_NAME_RE2.lastIndex = p;
+  const name = CONDITIONAL_NAME_RE2.exec(text)?.[0];
   if (name === void 0 || p + name.length > contentEnd) return null;
   p += name.length;
   if (text.charAt(p) !== "?") return null;
   p += 1;
-  return { name, inverted, bodyStart: p, sepIndex: firstTopLevelPipe(text, p, contentEnd) };
-}
-function splitConditional(content) {
-  const head = recognizeConditional(content, 0, content.length);
-  if (head === null) return null;
-  const body = content.slice(head.bodyStart);
-  const sep = head.sepIndex < 0 ? -1 : head.sepIndex - head.bodyStart;
-  return {
-    name: head.name,
-    inverted: head.inverted,
-    thenRaw: sep < 0 ? body : body.slice(0, sep),
-    elseRaw: sep < 0 ? "" : body.slice(sep + 1)
-  };
-}
-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/;
+  const sepIndex = anyPairs === void 0 ? firstTopLevelPipe(text, p, contentEnd) : firstTopLevelPipeByPairs(text, p, contentEnd, anyPairs);
+  return { name, inverted, bodyStart: p, sepIndex };
+}
+var CONFIG_KEY_RE = /\b(?:minsize|maxsize|sep|lastsep)[ \t\n\x0B\f\r]*=/i;
+var MINSIZE_RE = /minsize[ \t\n\x0B\f\r]*=[ \t\n\x0B\f\r]*(\d+)/i;
+var MAXSIZE_RE = /maxsize[ \t\n\x0B\f\r]*=[ \t\n\x0B\f\r]*(\d+)/i;
+var SEP_RE = /(?<!last)sep[ \t\n\x0B\f\r]*=[ \t\n\x0B\f\r]*"([^"]*)"/i;
+var LASTSEP_RE = /lastsep[ \t\n\x0B\f\r]*=[ \t\n\x0B\f\r]*"([^"]*)"/i;
+var HTML_TAG_RE = /^([a-zA-Z][a-zA-Z0-9-]*)(?:[ \t\n\x0B\f\r][^>]*)?\/?$/;
+var PER_ELEM_HTML_RE = /^[a-zA-Z][a-zA-Z0-9]*[ \t\n\x0B\f\r]/;
 function defaultPermConfig() {
   return { minsize: null, maxsize: null, sep: " ", lastsep: null };
 }
-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 extractPermutationConfig(index, start, end) {
+  const { text } = index;
+  let lt = start;
+  while (lt < end && isPhpTrimChar(text.charCodeAt(lt))) lt += 1;
+  if (lt === end || text.charCodeAt(lt) !== LT2) return { config: defaultPermConfig(), contentStart: start };
+  const gt = index.configEnd(lt, end);
+  if (gt === -1) return { config: defaultPermConfig(), contentStart: start };
+  const configStr = text.slice(lt + 1, gt);
+  if (looksLikeHtmlStartTag(index, configStr, gt + 1, end)) return { config: defaultPermConfig(), contentStart: start };
+  return { config: parseConfigString(configStr), contentStart: gt + 1 };
 }
 function parseConfigString(str) {
   if (!CONFIG_KEY_RE.test(str)) {
@@ -275,58 +608,54 @@ function parseConfigString(str) {
     lastsep: strGroup(LASTSEP_RE.exec(str))
   };
 }
-function looksLikeHtmlStartTag(tagText, remaining) {
+function looksLikeHtmlStartTag(index, tagText, from, end) {
   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);
+  return index.hasClosingTag((m[1] ?? "").toLowerCase(), from, end);
 }
-function permutationElements(rawParts) {
-  const texts = [];
+function permutationElements(index, parts) {
+  const { text } = index;
+  const spans = [];
   const separators = [];
   let pendingSep = null;
-  rawParts.forEach((part, i) => {
-    let text = part;
+  parts.forEach(([partStart, partEnd], i) => {
+    let textEnd = partEnd;
     let trailingSep = null;
-    if (i < rawParts.length - 1) {
-      const extracted = extractTrailingSep(part);
+    if (i < parts.length - 1) {
+      const extracted = extractTrailingSep(index, partStart, partEnd);
       if (extracted) {
-        text = extracted.text;
+        textEnd = extracted.textEnd;
         trailingSep = extracted.sep;
       }
     }
-    const trimmed = phpTrim(text);
-    if (trimmed !== "") {
-      texts.push(trimmed);
+    let a = partStart;
+    let b = textEnd;
+    while (a < b && isPhpTrimChar(text.charCodeAt(a))) a += 1;
+    while (b > a && isPhpTrimChar(text.charCodeAt(b - 1))) b -= 1;
+    if (b > a) {
+      spans.push([a, b]);
       separators.push(pendingSep);
     }
     pendingSep = trailingSep;
   });
-  return { texts, separators };
-}
-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);
+  return { spans, separators };
+}
+function extractTrailingSep(index, start, end) {
+  const { text } = index;
+  let len = end;
+  while (len > start && isPhpTrimChar(text.charCodeAt(len - 1))) len -= 1;
+  if (len === start || text.charCodeAt(len - 1) !== GT2) return null;
+  const openPos = index.lastAngleWithin(start, len - 2);
+  if (openPos === -1 || text.charCodeAt(openPos) === GT2) return null;
+  const inner = text.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 };
+  return { textEnd: openPos, sep: inner };
 }
 function intGroup(m) {
   return m && m[1] !== void 0 ? Number.parseInt(m[1], 10) : null;
@@ -334,52 +663,21 @@ function intGroup(m) {
 function strGroup(m) {
   return m && m[1] !== void 0 ? m[1] : null;
 }
-function escapeRegExp(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+function isPhpTrimChar(code) {
+  return code === 32 || code === 9 || code === 10 || code === 13 || code === 0 || code === 11;
 }
-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, "");
+  return phpRtrim(phpLtrim(s));
 }
 function phpLtrim(s) {
-  return s.replace(PHP_LTRIM_RE, "");
+  let start = 0;
+  while (start < s.length && isPhpTrimChar(s.charCodeAt(start))) start += 1;
+  return start === 0 ? s : s.slice(start);
 }
 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;
+  let end = s.length;
+  while (end > 0 && isPhpTrimChar(s.charCodeAt(end - 1))) end -= 1;
+  return end === s.length ? s : s.slice(0, end);
 }
 function firstTopLevelPipe(body, from = 0, to = body.length) {
   let depth = 0;
@@ -395,27 +693,35 @@ function firstTopLevelPipe(body, from = 0, to = body.length) {
   }
   return -1;
 }
+function firstTopLevelPipeByPairs(body, from, to, anyPairs) {
+  let j = from;
+  while (j < to) {
+    const code = body.charCodeAt(j);
+    if (code === BRACE_OPEN || code === BRACKET_OPEN) {
+      const close = anyPairs[j];
+      if (close === -1 || close >= to) return -1;
+      j = close + 1;
+    } else if (code === PIPE2) {
+      return j;
+    } else {
+      j += 1;
+    }
+  }
+  return -1;
+}
 
 // src/internal/plurals.ts
 var PLURAL_PREFIX2 = "{plural ";
 function findPluralBlocks(text) {
   const blocks = [];
+  let close = null;
   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) {
+    close ??= matchPairs(text, BRACE_OPEN, BRACE_CLOSE);
+    const j = close[start];
+    if (j === -1) {
       i = start + PLURAL_PREFIX2.length;
       continue;
     }
@@ -578,12 +884,19 @@ function checkDirectives(text, out) {
     }
   }
 }
+var CONFIG_KEY_PRESENT_RE = /(?<!\w)\w+[ \t\n\x0B\f\r]*=/;
+var CONFIG_KEYS_RE = /(?<!\w)(\w+)[ \t\n\x0B\f\r]*=/gu;
 function checkPermutationConfigs(text, idx, out) {
-  for (const m of text.matchAll(/\[<([^>]*?)>/gu)) {
-    const configStr = m[1] ?? "";
-    if (!/\w+\s*=/.test(configStr)) continue;
-    const configBase = (m.index ?? 0) + 2;
-    for (const km of configStr.matchAll(/(\w+)\s*=/gu)) {
+  for (let from = 0; ; ) {
+    const open = text.indexOf("[<", from);
+    if (open === -1) break;
+    const configBase = open + 2;
+    const gt = text.indexOf(">", configBase);
+    if (gt === -1) break;
+    from = gt + 1;
+    const configStr = text.slice(configBase, gt);
+    if (!CONFIG_KEY_PRESENT_RE.test(configStr)) continue;
+    for (const km of configStr.matchAll(CONFIG_KEYS_RE)) {
       const key = (km[1] ?? "").toLowerCase();
       if (!KNOWN_CONFIG_KEYS.has(key)) {
         out.push(err(
@@ -593,7 +906,7 @@ function checkPermutationConfigs(text, idx, out) {
         ));
       }
     }
-    const min = /minsize\s*=\s*([^;>\s]+)/i.exec(configStr);
+    const min = /minsize[ \t\n\x0B\f\r]*=[ \t\n\x0B\f\r]*([^;> \t\n\x0B\f\r]+)/i.exec(configStr);
     if (min && !/^\d+$/.test(min[1] ?? "")) {
       out.push(err(
         "permutation.minsize-not-integer",
@@ -601,7 +914,7 @@ function checkPermutationConfigs(text, idx, out) {
         { ...span(idx, configBase + min.index, min[0].length), data: { value: min[1] } }
       ));
     }
-    const max = /maxsize\s*=\s*([^;>\s]+)/i.exec(configStr);
+    const max = /maxsize[ \t\n\x0B\f\r]*=[ \t\n\x0B\f\r]*([^;> \t\n\x0B\f\r]+)/i.exec(configStr);
     if (max && !/^\d+$/.test(max[1] ?? "")) {
       out.push(err(
         "permutation.maxsize-not-integer",
@@ -924,6 +1237,13 @@ function addAll(target, text, re, fold) {
   }
 }
 
+// src/internal/charclass.ts
+var UCP_SPACE = "\\t\\n\\x0B\\f\\r \\x85\\xA0\\u1680\\u180E\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000";
+function isUcpSpace(code) {
+  return code >= 9 && code <= 13 || code === 32 || code === 133 || code === 160 || code === 5760 || code === 6158 || code >= 8192 && code <= 8202 || code === 8232 || code === 8233 || code === 8239 || code === 8287 || code === 12288;
+}
+var UCP_WORD = "\\p{L}\\p{N}\\p{Mn}\\p{Pc}";
+
 // src/internal/errors.ts
 var SpintaxError = class extends Error {
   constructor(message) {
@@ -953,6 +1273,120 @@ var NotImplementedError = class extends SpintaxError {
   }
 };
 
+// src/internal/fragment.ts
+var FLAT_BELOW = 128;
+var Join = class {
+  constructor(pieces) {
+    this.pieces = pieces;
+    let length = 0;
+    for (const piece of pieces) length += lengthOf(piece);
+    this.length = length;
+    let lead = 0;
+    for (const piece of pieces) {
+      const pieceLead = leadOf(piece);
+      lead += pieceLead;
+      if (pieceLead < lengthOf(piece)) break;
+    }
+    this.lead = lead;
+    let trail = 0;
+    if (lead < length) {
+      for (let k = pieces.length - 1; k >= 0; k -= 1) {
+        const piece = pieces[k];
+        const pieceTrail = trailOf(piece);
+        trail += pieceTrail;
+        if (pieceTrail < lengthOf(piece)) break;
+      }
+    } else {
+      trail = length;
+    }
+    this.trail = trail;
+  }
+  pieces;
+  length;
+  lead;
+  trail;
+};
+var Window = class {
+  constructor(base, from, to) {
+    this.base = base;
+    this.from = from;
+    this.to = to;
+    this.length = to - from;
+  }
+  base;
+  from;
+  to;
+  length;
+  lead = 0;
+  trail = 0;
+};
+function lengthOf(fragment) {
+  return fragment.length;
+}
+function leadOf(fragment) {
+  if (typeof fragment !== "string") return fragment.lead;
+  let k = 0;
+  while (k < fragment.length && isPhpTrimChar(fragment.charCodeAt(k))) k += 1;
+  return k;
+}
+function trailOf(fragment) {
+  if (typeof fragment !== "string") return fragment.trail;
+  let k = fragment.length;
+  while (k > 0 && isPhpTrimChar(fragment.charCodeAt(k - 1))) k -= 1;
+  return fragment.length - k;
+}
+function joinFragments(pieces) {
+  if (pieces.length === 0) return "";
+  if (pieces.length === 1) return pieces[0];
+  let total = 0;
+  let flat = true;
+  for (const piece of pieces) {
+    total += lengthOf(piece);
+    if (typeof piece !== "string") flat = false;
+  }
+  if (flat && total < FLAT_BELOW) return pieces.join("");
+  return new Join(pieces);
+}
+function trimFragment(fragment) {
+  if (typeof fragment === "string") {
+    let start = 0;
+    while (start < fragment.length && isPhpTrimChar(fragment.charCodeAt(start))) start += 1;
+    let end = fragment.length;
+    while (end > start && isPhpTrimChar(fragment.charCodeAt(end - 1))) end -= 1;
+    return start === 0 && end === fragment.length ? fragment : fragment.slice(start, end);
+  }
+  if (fragment.lead === fragment.length) return "";
+  if (fragment.lead === 0 && fragment.trail === 0) return fragment;
+  return new Window(fragment, fragment.lead, fragment.length - fragment.trail);
+}
+function flatten(fragment) {
+  if (typeof fragment === "string") return fragment;
+  const out = [];
+  const stack = [[fragment, 0, fragment.length]];
+  while (stack.length > 0) {
+    const [piece, from, to] = stack.pop();
+    if (from >= to) continue;
+    if (typeof piece === "string") {
+      out.push(from === 0 && to === piece.length ? piece : piece.slice(from, to));
+    } else if (piece instanceof Window) {
+      stack.push([piece.base, piece.from + from, piece.from + to]);
+    } else {
+      const wanted = [];
+      let offset = 0;
+      for (const child of piece.pieces) {
+        const length = lengthOf(child);
+        const a = Math.max(from, offset);
+        const b = Math.min(to, offset + length);
+        if (a < b) wanted.push([child, a - offset, b - offset]);
+        offset += length;
+        if (offset >= to) break;
+      }
+      for (let k = wanted.length - 1; k >= 0; k -= 1) stack.push(wanted[k]);
+    }
+  }
+  return out.join("");
+}
+
 // src/internal/render.ts
 var MAX_VARIABLE_DEPTH = 50;
 var MAX_EXPANSION_CHARS = 1024 * 1024;
@@ -966,7 +1400,7 @@ function renderAst(ast, ctx) {
     onPluralError: ctx.onPluralError,
     budget: ctx.budget
   };
-  const vars = Object.keys(ast.defDefs).length > 0 ? { ...base, ...rollDefinitions(ast.defDefs, base, ctx.runtimeContext, walkOpts) } : base;
+  const vars = Object.keys(ast.defDefs).length > 0 ? nameMap(base, rollDefinitions(ast.defDefs, base, ctx.runtimeContext, walkOpts)) : base;
   const text = renderNodes(ast.nodes, { ...walkOpts, vars });
   return ctx.resolver ? resolveIncludes(text, ctx) : text;
 }
@@ -990,7 +1424,7 @@ function resolveIncludes(text, ctx) {
   });
 }
 function buildVars(setDefs, context) {
-  const vars = {};
+  const vars = nameMap();
   for (const [name, value] of Object.entries(setDefs)) {
     vars[name] = value;
   }
@@ -1001,16 +1435,17 @@ function buildVars(setDefs, context) {
 }
 function rollDefinitions(defDefs, vars, context, opts) {
   const outranked = new Set(Object.keys(context).map((key) => key.toLowerCase()));
-  const rolled = {};
-  const aliases = {};
+  const rolled = nameMap();
+  const definitions = nameMap(defDefs);
+  const aliases = nameMap();
   for (const [name, value] of Object.entries(vars)) {
-    if (name in defDefs && !outranked.has(name)) continue;
+    if (name in definitions && !outranked.has(name)) continue;
     aliases[name] = value;
   }
-  for (const name of orderDefinitions(defDefs, aliases)) {
+  for (const name of orderDefinitions(definitions, aliases)) {
     if (outranked.has(name)) continue;
-    const value = defDefs[name] ?? "";
-    rolled[name] = renderNodes(parseSequence(value), { ...opts, vars: { ...vars, ...rolled } });
+    const value = definitions[name] ?? "";
+    rolled[name] = renderNodes(parseSequence(value), { ...opts, vars: nameMap(vars, rolled) });
   }
   return rolled;
 }
@@ -1050,6 +1485,9 @@ function directReferences(text) {
   return [...text.matchAll(/%(\w+)%/gu)].map((match) => (match[1] ?? "").toLowerCase());
 }
 function renderNodes(nodes, opts) {
+  return flatten(renderFragment(nodes, opts));
+}
+function renderFragment(nodes, opts) {
   const frame = (list) => ({ nodes: list, i: 0, out: [], pending: null });
   const stack = [frame(nodes)];
   while (stack.length > 0) {
@@ -1064,7 +1502,7 @@ function renderNodes(nodes, opts) {
       continue;
     }
     if (f.i >= f.nodes.length) {
-      const text = f.out.join("");
+      const text = joinFragments(f.out);
       stack.pop();
       const parent = stack[stack.length - 1];
       if (parent === void 0) return text;
@@ -1074,11 +1512,12 @@ function renderNodes(nodes, opts) {
     const node = f.nodes[f.i];
     f.i += 1;
     const step = renderNode(node, opts);
-    if (typeof step === "string") f.out.push(step);
+    if (typeof step === "string" || !("lists" in step)) f.out.push(step);
     else f.pending = step;
   }
   return "";
 }
+var single = (list) => ({ lists: [list], done: [], assemble: (parts) => parts[0] ?? "" });
 function renderNode(node, opts) {
   switch (node.type) {
     case "literal":
@@ -1086,7 +1525,7 @@ function renderNode(node, opts) {
     case "variable":
       return resolveVariable(node.name, opts);
     case "enumeration":
-      return renderEnumeration(node.options, opts);
+      return renderEnumeration(node, opts);
     case "permutation":
       return renderPermutation(node, opts);
     case "conditional":
@@ -1100,15 +1539,20 @@ function randomInt(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;
+  if (value === void 0 || opts.frozen === true) return `%${name}%`;
   if (opts.budget.left <= 0) return `%${name}%`;
   opts.budget.left -= value.length;
-  return renderNodes(parseSequence(value), { ...opts, depth: opts.depth + 1 });
+  if (opts.depth >= MAX_VARIABLE_DEPTH || !/[{[%]/u.test(value)) return value;
+  return renderFragment(parseSequence(value), { ...opts, depth: opts.depth + 1 });
 }
-function expandVarsOnly(text, opts) {
+function passesLeft(opts) {
+  return Math.max(1, MAX_VARIABLE_DEPTH - opts.depth + 1);
+}
+function expandVarsFixpoint(text, opts, passes) {
+  if (opts.frozen === true) return { text, changed: false, converged: true };
   let out = text;
-  for (let i = 0; i < MAX_VARIABLE_DEPTH; i += 1) {
+  let changedAny = false;
+  for (let i = 0; i < passes; i += 1) {
     let changed = false;
     out = out.replace(/%(\w+)%/gu, (m, name) => {
       const value = opts.vars[name.toLowerCase()];
@@ -1118,22 +1562,34 @@ function expandVarsOnly(text, opts) {
       changed = true;
       return value;
     });
-    if (!changed) break;
+    if (!changed) return { text: out, changed: changedAny, converged: true };
+    changedAny = true;
   }
-  return out;
+  return { text: out, changed: changedAny, converged: false };
 }
+var NON_SPACE_RE = new RegExp(`[^${UCP_SPACE}]`, "u");
+var truthinessByVars = /* @__PURE__ */ new WeakMap();
 function conditionalTakesThen(name, inverted, opts) {
-  const value = opts.vars[name.toLowerCase()];
-  const baseTruthy = value !== void 0 && /\S/u.test(value);
+  const key = name.toLowerCase();
+  let known = truthinessByVars.get(opts.vars);
+  if (known === void 0) truthinessByVars.set(opts.vars, known = /* @__PURE__ */ new Map());
+  let baseTruthy = known.get(key);
+  if (baseTruthy === void 0) {
+    const value = opts.vars[key];
+    baseTruthy = value !== void 0 && NON_SPACE_RE.test(value);
+    known.set(key, baseTruthy);
+  }
   return inverted ? !baseTruthy : baseTruthy;
 }
 function renderConditional(node, opts) {
-  const truthy = conditionalTakesThen(node.name, node.inverted, opts);
-  return { lists: [truthy ? node.then : node.else], done: [], assemble: (parts) => parts[0] ?? "" };
+  return single(conditionalTakesThen(node.name, node.inverted, opts) ? node.then : node.else);
 }
-function resolveCountConditionals(text, opts) {
+function resolveConditionalsInText(text, opts) {
   if (!text.includes("{?")) return text;
-  const close = matchBraces(text);
+  const close = matchPairs(text, BRACE_OPEN, BRACE_CLOSE);
+  const any = matchAnyPairs(text);
+  const heads = [];
+  for (let at = text.indexOf("{?"); at !== -1; at = text.indexOf("{?", at + 1)) heads.push(at);
   const out = [];
   const pending = [[0, text.length]];
   while (pending.length > 0) {
@@ -1141,13 +1597,14 @@ function resolveCountConditionals(text, opts) {
     const segEnd = segment[1];
     let i = segment[0];
     while (i < segEnd) {
-      const open = text.indexOf("{?", i);
+      const next = lowerBound(heads, i);
+      const open = next < heads.length ? heads[next] : -1;
       if (open === -1 || open + 1 >= segEnd) {
         out.push(text.slice(i, segEnd));
         break;
       }
       const shut = close[open] ?? -1;
-      const head = shut === -1 || shut >= segEnd ? null : recognizeConditional(text, open + 1, shut);
+      const head = shut === -1 || shut >= segEnd ? null : recognizeConditional(text, open + 1, shut, any);
       if (head === null) {
         out.push(text.slice(i, Math.min(open + 2, segEnd)));
         i = open + 2;
@@ -1163,23 +1620,12 @@ function resolveCountConditionals(text, opts) {
   }
   return out.join("");
 }
-function matchBraces(text) {
-  const close = new Int32Array(text.length).fill(-1);
-  const opens = [];
-  for (let i = 0; i < text.length; i += 1) {
-    const ch = text.charAt(i);
-    if (ch === "{") {
-      opens.push(i);
-    } else if (ch === "}") {
-      const open = opens.pop();
-      if (open !== void 0) close[open] = i;
-    }
-  }
-  return close;
-}
 function renderPlural(node, opts) {
-  const countRaw = resolveCountConditionals(expandVarsOnly(node.countRaw, opts), opts);
-  const formsRaw = expandVarsOnly(node.formsRaw, opts);
+  const passes = passesLeft(opts);
+  const countPass = expandVarsFixpoint(node.countRaw, opts, passes);
+  const formsPass = expandVarsFixpoint(node.formsRaw, opts, passes);
+  const countRaw = resolveConditionalsInText(countPass.text, opts);
+  const formsRaw = formsPass.text;
   const base = normalizeBaseLang(opts.locale);
   const report = (issue) => opts.onPluralError?.(issue);
   if (/[{}[\]]/u.test(formsRaw)) {
@@ -1191,7 +1637,7 @@ function renderPlural(node, opts) {
     });
     return fullwidthVerbatim(countRaw, formsRaw);
   }
-  const count = phpTrim2(countRaw);
+  const count = phpTrim(countRaw);
   if (!/^-?\d+$/u.test(count)) {
     report({
       code: "plural.count",
@@ -1201,7 +1647,7 @@ function renderPlural(node, opts) {
     });
     return "";
   }
-  const forms = formsRaw.split("|").map((f) => phpTrim2(f));
+  const forms = formsRaw.split("|").map((f) => phpTrim(f));
   if (forms.length !== pluralArity(base)) {
     report({
       code: "plural.arity",
@@ -1214,7 +1660,8 @@ function renderPlural(node, opts) {
     return fullwidthVerbatim(countRaw, formsRaw);
   }
   const picked = pluralFor(base, Number.parseInt(count, 10), forms);
-  return { lists: [parseSequence(picked)], done: [], assemble: (parts) => parts[0] ?? "" };
+  if (!formsPass.converged) return renderFragment(parseSequence(picked), { ...opts, frozen: true });
+  return single(parseSequence(picked));
 }
 function rawConstruct(countRaw, formsRaw) {
   return `{plural ${countRaw}:${formsRaw}}`;
@@ -1222,13 +1669,33 @@ function rawConstruct(countRaw, formsRaw) {
 function fullwidthVerbatim(countRaw, formsRaw) {
   return rawConstruct(countRaw, formsRaw).replace(/\{/gu, "\uFF5B").replace(/\}/gu, "\uFF5D");
 }
-function renderEnumeration(options, opts) {
+function renderEnumeration(node, opts) {
+  const spliced = node.raw === void 0 ? null : spliceConstruct(node, node.raw, "{", "}", opts);
+  if (spliced !== null) return spliced;
+  const { options } = node;
   if (options.length === 0) return "";
   const picked = options[randomInt(opts.rng, 0, options.length - 1)];
   if (!picked) return "";
-  return { lists: [picked], done: [], assemble: (parts) => parts[0] ?? "" };
+  return single(picked);
+}
+function spliceConstruct(node, raw, open, close, opts) {
+  if (opts.frozen === true) return null;
+  const span2 = rereadSpans.get(node);
+  if (span2 !== void 0 && !rereadCouldChange(span2, opts)) return null;
+  const expanded = expandVarsFixpoint(resolveConditionalsInText(raw, opts), opts, passesLeft(opts));
+  const body = resolveConditionalsInText(expanded.text, opts);
+  if (body === raw) return null;
+  const nodes = parseSequence(open + body + close);
+  if (!expanded.converged) return renderFragment(nodes, { ...opts, frozen: true });
+  return single(nodes);
+}
+function rereadCouldChange({ index, start, end }, opts) {
+  if (index.hasConditionalWithin(start, end)) return true;
+  return !(opts.budget.left <= 0) && index.hasDefinedReferenceWithin(start, end, opts.vars);
 }
 function renderPermutation(node, opts) {
+  const spliced = node.raw === void 0 ? null : spliceConstruct(node, node.raw, "[", "]", opts);
+  if (spliced !== null) return spliced;
   if (node.options.length === 0) return "";
   return {
     lists: node.options.map((o) => o.nodes),
@@ -1237,7 +1704,11 @@ function renderPermutation(node, opts) {
   };
 }
 function assemblePermutation(node, rendered, opts) {
-  const elements = node.options.map((o, i) => ({ text: rendered[i] ?? "", sep: o.separator }));
+  const elements = [];
+  node.options.forEach((o, i) => {
+    const text = trimFragment(rendered[i] ?? "");
+    if (lengthOf(text) !== 0) elements.push({ text, sep: o.separator });
+  });
   const total = elements.length;
   if (total === 0) return "";
   const { config } = node;
@@ -1276,25 +1747,20 @@ 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;
+  const pieces = [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;
+    pieces.push(padSeparator(sep), el.text);
   }
-  return out;
+  return joinFragments(pieces);
 }
 function padSeparator(sep) {
-  const trimmed = phpTrim2(sep);
+  const trimmed = phpTrim(sep);
   if (trimmed === "") return sep;
   if (/^\p{L}+$/u.test(trimmed)) return ` ${trimmed} `;
   return sep;
 }
-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 = [
@@ -1347,41 +1813,179 @@ var SINGLE_ABBREVS = [
   "Ave",
   "Blvd"
 ];
-var WS = " \\t\\r\\n\\f\\x0B";
+var WS = UCP_SPACE;
 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 AFTER_NON_WORD = `(?<![${UCP_WORD}])`;
+var WORD_BOUNDARY = `(?:(?<=[${UCP_WORD}])(?![${UCP_WORD}])|(?<![${UCP_WORD}])(?=[${UCP_WORD}]))`;
+var LABEL = "(?:xn--)?[\\p{L}\\p{N}]+(?:-[\\p{L}\\p{N}]+)*";
+var DOMAIN_PART = `(?:${LABEL}\\.)+(?:xn--[a-z0-9\\-]{2,59}|[\\p{L}][\\p{L}\\p{N}-]{1,62})`;
 var URI_BODY = `[^\\x00${WS}<>"')\\]]`;
 var URI_RE = new RegExp(`(?:(?:https?|ftp):\\/\\/|(?:mailto|tel):)${URI_BODY}+`, "giu");
 var MAILTEL_PREFIX_RE = /^(?:mailto|tel):/iu;
-var EMAIL_RE = new RegExp(`[a-z0-9._%+\\-]+@${DOMAIN_PART}\\b`, "giu");
-var DOMAIN_RE = new RegExp(`\\b${DOMAIN_PART}\\b`, "giu");
+var DOMAIN_AT_RE = new RegExp(`${DOMAIN_PART}${WORD_BOUNDARY}`, "iuy");
+var DOMAIN_SCAN_RE = new RegExp(`${AFTER_NON_WORD}(?:(${DOMAIN_PART}${WORD_BOUNDARY})|(?:${LABEL}\\.)*${LABEL})`, "giu");
 var DECIMAL_RE = /\b\d+\.\d+\b/gu;
-var MULTI_ABBR_RE = new RegExp(`\\b(?:\\p{L}{1,2}\\.${S}*){2,}`, "gu");
+var MULTI_ABBR_RE = new RegExp(`${AFTER_NON_WORD}(?:\\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;
+function isEmailLocalChar(code) {
+  return code >= 97 && code <= 122 || code >= 65 && code <= 90 || code >= 48 && code <= 57 || code === 46 || code === 95 || code === 37 || code === 43 || code === 45 || code === 383 || code === 8490;
+}
+function shieldEmails(text, shield) {
+  let out = "";
+  let emitted = 0;
+  let pos = 0;
+  for (let at = text.indexOf("@"); at !== -1; at = text.indexOf("@", Math.max(at + 1, pos))) {
+    let start = at;
+    while (start > pos && isEmailLocalChar(text.charCodeAt(start - 1))) start -= 1;
+    if (start === at) continue;
+    DOMAIN_AT_RE.lastIndex = at + 1;
+    if (DOMAIN_AT_RE.exec(text) !== null) {
+      out += text.slice(emitted, start) + shield(text.slice(start, DOMAIN_AT_RE.lastIndex));
+      emitted = pos = DOMAIN_AT_RE.lastIndex;
+    }
+  }
+  return emitted === 0 ? text : out + text.slice(emitted);
+}
+var DOMAIN_DOT_RE = /\.[\p{L}\p{N}]/u;
+function shieldDomains(text, shield) {
+  if (!DOMAIN_DOT_RE.test(text)) return text;
+  let out = "";
+  let emitted = 0;
+  DOMAIN_SCAN_RE.lastIndex = 0;
+  for (let m = DOMAIN_SCAN_RE.exec(text); m !== null; m = DOMAIN_SCAN_RE.exec(text)) {
+    if (m[1] !== void 0) {
+      out += text.slice(emitted, m.index) + shield(m[1]);
+      emitted = m.index + m[1].length;
+    }
+  }
+  return emitted === 0 ? text : out + text.slice(emitted);
+}
+function trailingPunctuationStart(value) {
+  let cut = value.length;
+  while (cut > 0 && ".,;:!".includes(value.charAt(cut - 1))) cut -= 1;
+  return cut;
+}
 var SENTENCE_OPENERS = "\xBF\xA1";
 var LEAD = `(?:<[^>]+>|[${SENTENCE_OPENERS}]|${S})*`;
-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 SPACE_BEFORE_PUNCT_RE = new RegExp(`(?<!${S})${S}+([,;:!?.])`, "gu");
+var SPACE_AFTER_COMMA_RE = new RegExp(`([,;:])(?!\\p{Nd})(?!${S}|$|<)`, "gu");
+var SPACE_AFTER_SENTENCE_RE = new RegExp(`(?<![.!?])([.!?]+)(?![.!?])(?!\\p{Nd})(?!${S}|$|<)`, "gu");
 var SPACE_AFTER_OPENER_RE = new RegExp(`([${SENTENCE_OPENERS}])${S}+`, "gu");
 var CAP_FIRST_RE = new RegExp(`^(${LEAD})(\\p{Ll})`, "u");
-var CAP_AFTER_SENTENCE_RE = new RegExp(`([.!?\u2026])(${LEAD})(\\p{Ll})`, "gu");
-var CAP_AFTER_BLOCK_RE = new RegExp(
-  `(<\\/?(?:p|h[1-6]|li|blockquote|div|td|th)[^>]*>${LEAD})(\\p{Ll})`,
-  "giu"
-);
-var CAP_AFTER_BREAK_RE = new RegExp(`(\\n${LEAD})(\\p{Ll})`, "gu");
 var up = (ch) => ch.toUpperCase();
+function indexLeads(text) {
+  const n = text.length;
+  const leadEnd = new Int32Array(n + 1);
+  leadEnd[n] = n;
+  let gt = -1;
+  for (let i = n - 1; i >= 0; i -= 1) {
+    const code = text.charCodeAt(i);
+    let tokenEnd = -1;
+    if (code === 191 || code === 161 || isUcpSpace(code)) {
+      tokenEnd = i + 1;
+    } else if (code === 60 && gt > i + 1) {
+      tokenEnd = gt + 1;
+    }
+    leadEnd[i] = tokenEnd === -1 ? i : leadEnd[tokenEnd];
+    if (code === 62) gt = i;
+  }
+  return { leadEnd };
+}
+var LOWER_RE = /^\p{Ll}/u;
+var LOWER_CASELESS_RE = /^\p{Ll}/iu;
+var BLOCK_TAG_NAME_RE = /<\/?(?:p|h[1-6]|li|blockquote|div|td|th)/iuy;
+var SENTENCE_END_SCAN_RE = new RegExp(`[.!?${String.fromCharCode(8230)}]`, "g");
+var LEAD_WALK = 32;
+function leadEndFrom(text, i, leads) {
+  let j = i;
+  for (let steps = 0; steps < LEAD_WALK && j < text.length; steps += 1) {
+    const code = text.charCodeAt(j);
+    if (code === 60) return leads().leadEnd[j];
+    if (code !== 191 && code !== 161 && !isUcpSpace(code)) return j;
+    j += 1;
+  }
+  return j < text.length ? leads().leadEnd[j] : j;
+}
+function capitalizeAfter(text, lower, next, context) {
+  const leads = () => {
+    if (context.leads === null || context.leads.leadEnd.length !== text.length + 1) context.leads = indexLeads(text);
+    return context.leads;
+  };
+  let out = "";
+  let emitted = 0;
+  let from = 0;
+  for (let boundary = next(text, from); boundary !== null; boundary = next(text, from)) {
+    from = boundary.resume;
+    const at = leadEndFrom(text, boundary.leadStart, leads);
+    const cp = text.codePointAt(at);
+    if (cp === void 0) continue;
+    const ch = String.fromCodePoint(cp);
+    if (!lower.test(ch)) continue;
+    out += text.slice(emitted, at) + up(ch);
+    emitted = at + ch.length;
+    from = emitted;
+  }
+  return emitted === 0 ? text : out + text.slice(emitted);
+}
+var afterSentenceEnd = (text, from) => {
+  SENTENCE_END_SCAN_RE.lastIndex = from;
+  const m = SENTENCE_END_SCAN_RE.exec(text);
+  return m === null ? null : { leadStart: m.index + 1, resume: m.index + 1 };
+};
+function afterBlockTag() {
+  let gtFrom = -1;
+  let gt = -1;
+  return (text, from) => {
+    for (let lt = text.indexOf("<", from); lt !== -1; lt = text.indexOf("<", lt + 1)) {
+      BLOCK_TAG_NAME_RE.lastIndex = lt;
+      if (!BLOCK_TAG_NAME_RE.test(text)) continue;
+      const nameEnd = BLOCK_TAG_NAME_RE.lastIndex;
+      if (gtFrom === -1 || nameEnd < gtFrom || gt !== -1 && nameEnd > gt) {
+        gtFrom = nameEnd;
+        gt = text.indexOf(">", nameEnd);
+      }
+      if (gt === -1) continue;
+      return { leadStart: gt + 1, resume: lt + 1 };
+    }
+    return null;
+  };
+}
+var afterLineBreak = (text, from) => {
+  const at = text.indexOf("\n", from);
+  return at === -1 ? null : { leadStart: at + 1, resume: at + 1 };
+};
 var SHIELD_PREFIXES = ["URL", "URI", "EMAIL", "DOM", "NUM", "ABBR"];
 var RESTORE_RE2 = new RegExp(`\\x00(?:${SHIELD_PREFIXES.join("|")})_\\d+\\x00`, "gu");
 function restore(text, input, placeholders) {
   if (!input.includes("\0")) {
     return text.replace(RESTORE_RE2, (key) => placeholders.get(key) ?? key);
   }
-  let out = text;
-  for (const [key, value] of placeholders) {
-    out = out.split(key).join(value);
+  return restoreAsTheLoopDoes(text, placeholders);
+}
+function restoreAsTheLoopDoes(text, placeholders) {
+  const gaps = text.split("\0");
+  const rank = /* @__PURE__ */ new Map();
+  for (const key of placeholders.keys()) rank.set(key, rank.size);
+  const byRank = [];
+  for (let j = 1; j < gaps.length - 1; j += 1) {
+    const r = rank.get(`\0${gaps[j]}\0`);
+    if (r !== void 0) (byRank[r] ??= []).push(j);
+  }
+  const taken = new Uint8Array(gaps.length);
+  const replaced = new Uint8Array(gaps.length);
+  for (const candidates of byRank) {
+    for (const j of candidates ?? []) {
+      if (taken[j - 1] === 1 || taken[j] === 1) continue;
+      taken[j - 1] = 1;
+      taken[j] = 1;
+      replaced[j] = 1;
+    }
+  }
+  let out = gaps[0];
+  for (let j = 1; j < gaps.length; j += 1) {
+    if (taken[j - 1] !== 1) out += "\0";
+    const gap = gaps[j];
+    out += replaced[j] === 1 ? placeholders.get(`\0${gap}\0`) : gap;
   }
   return out;
 }
@@ -1395,21 +1999,17 @@ function postProcess(input) {
     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);
+    const cut = trailingPunctuationStart(value);
+    if (cut === value.length) return store(value, prefix);
+    return cut === 0 ? value : store(value.slice(0, cut), prefix) + value.slice(cut);
   };
   let text = input;
   text = text.replace(
     URI_RE,
     (m) => storeWithTrailingPunct(m, MAILTEL_PREFIX_RE.test(m) ? "URI" : "URL")
   );
-  text = text.replace(EMAIL_RE, (m) => store(m, "EMAIL"));
-  text = text.replace(DOMAIN_RE, (m) => store(m, "DOM"));
+  text = shieldEmails(text, (m) => store(m, "EMAIL"));
+  text = shieldDomains(text, (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"));
@@ -1419,9 +2019,10 @@ function postProcess(input) {
   text = text.replace(SPACE_AFTER_SENTENCE_RE, "$1 ");
   text = text.replace(SPACE_AFTER_OPENER_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));
+  const leadContext = { leads: null };
+  text = capitalizeAfter(text, LOWER_RE, afterSentenceEnd, leadContext);
+  text = capitalizeAfter(text, LOWER_CASELESS_RE, afterBlockTag(), leadContext);
+  text = capitalizeAfter(text, LOWER_RE, afterLineBreak, leadContext);
   return restore(text, input, placeholders).trim();
 }