@spintax/core 0.8.0 → 0.9.0

package/dist/index.js

@@ -1098,11 +1098,12 @@ function checkVariableReferences(text, idx, known, out) {
     refsOf.set(name, refs);
   }
   const { reaches: reachesCycle, via } = namesThatReachACycle(defs, refsOf);
+  const lengths = routeLengths(via);
   for (const name of defs.keys()) {
     if (!reachesCycle.has(name)) continue;
     out.push(err(
       "variable.circular-reference",
-      `Circular variable reference: ${cyclePath(name, via)}.`,
+      `Circular variable reference: ${cyclePath(name, via, lengths)}.`,
       { ...defPos.get(name) ?? somewhere, data: { name } }
     ));
   }
@@ -1162,7 +1163,7 @@ function namesThatReachACycle(defs, refsOf) {
   return { reaches, via };
 }
 var CYCLE_PATH_LIMIT = 8;
-function cyclePath(name, via) {
+function cyclePath(name, via, lengths) {
   const seen = /* @__PURE__ */ new Set([name]);
   const shown = [name];
   let current = name;
@@ -1174,16 +1175,7 @@ function cyclePath(name, via) {
       return shown.join(" \u2192 ");
     }
     if (shown.length >= CYCLE_PATH_LIMIT) {
-      let more = 0;
-      let walk2 = next;
-      while (!seen.has(walk2)) {
-        seen.add(walk2);
-        more += 1;
-        const step = via.get(walk2);
-        if (step === void 0) break;
-        walk2 = step;
-      }
-      return `${shown.join(" \u2192 ")} \u2192 \u2026 (${more} more)`;
+      return `${shown.join(" \u2192 ")} \u2192 \u2026 (${lengths.get(name) - shown.length} more)`;
     }
     seen.add(next);
     shown.push(next);
@@ -1191,6 +1183,33 @@ function cyclePath(name, via) {
   }
   return shown.join(" \u2192 ");
 }
+function routeLengths(via) {
+  const lengths = /* @__PURE__ */ new Map();
+  for (const start of via.keys()) {
+    if (lengths.has(start)) continue;
+    const walk2 = [];
+    const onWalk = /* @__PURE__ */ new Map();
+    let node = start;
+    while (node !== void 0 && !lengths.has(node) && !onWalk.has(node)) {
+      onWalk.set(node, walk2.length);
+      walk2.push(node);
+      node = via.get(node);
+    }
+    let tailEnd = walk2.length;
+    let length = node === void 0 ? 0 : lengths.get(node) ?? 0;
+    if (node !== void 0 && onWalk.has(node)) {
+      const from = onWalk.get(node);
+      length = walk2.length - from;
+      for (let k = from; k < walk2.length; k += 1) lengths.set(walk2[k], length);
+      tailEnd = from;
+    }
+    for (let k = tailEnd - 1; k >= 0; k -= 1) {
+      length += 1;
+      lengths.set(walk2[k], length);
+    }
+  }
+  return lengths;
+}
 function checkIncludeTargets(text, idx, known, out) {
   const set = new Set(known);
   INCLUDE_RE.lastIndex = 0;
@@ -1442,42 +1461,61 @@ function rollDefinitions(defDefs, vars, context, opts) {
     if (name in definitions && !outranked.has(name)) continue;
     aliases[name] = value;
   }
+  const visible = nameMap(vars);
   for (const name of orderDefinitions(definitions, aliases)) {
     if (outranked.has(name)) continue;
-    const value = definitions[name] ?? "";
-    rolled[name] = renderNodes(parseSequence(value), { ...opts, vars: nameMap(vars, rolled) });
+    const value = renderNodes(parseSequence(definitions[name] ?? ""), { ...opts, vars: visible });
+    rolled[name] = value;
+    visible[name] = value;
+    truthinessByVars.delete(visible);
   }
   return rolled;
 }
 function orderDefinitions(defDefs, aliases) {
   const names = Object.keys(defDefs);
-  const blocked = /* @__PURE__ */ new Map();
+  const position = new Map(names.map((name, i) => [name, i]));
+  const unplaced = /* @__PURE__ */ new Map();
+  const waitingOn = /* @__PURE__ */ new Map();
   for (const name of names) {
-    const reached = referencedNames(defDefs[name] ?? "", aliases);
-    blocked.set(name, new Set(names.filter((candidate) => reached.has(candidate))));
+    let count = 0;
+    for (const dep of referencedNames(defDefs[name] ?? "", aliases)) {
+      if (dep === name || !position.has(dep)) continue;
+      count += 1;
+      const waiting = waitingOn.get(dep);
+      if (waiting === void 0) waitingOn.set(dep, [name]);
+      else waiting.push(name);
+    }
+    unplaced.set(name, count);
   }
   const ordered = [];
-  let pending = names;
-  while (pending.length > 0) {
-    const ready = pending.filter((name) => {
-      const deps = blocked.get(name);
-      return !deps || ![...deps].some((dep) => dep !== name && pending.includes(dep));
-    });
-    if (ready.length === 0) return [...ordered, ...pending];
-    ordered.push(...ready);
-    pending = pending.filter((name) => !ready.includes(name));
+  let round = names.filter((name) => unplaced.get(name) === 0);
+  while (round.length > 0) {
+    const next = [];
+    for (const name of round) {
+      ordered.push(name);
+      for (const waiting of waitingOn.get(name) ?? []) {
+        const left = unplaced.get(waiting) - 1;
+        unplaced.set(waiting, left);
+        if (left === 0) next.push(waiting);
+      }
+    }
+    round = next.sort((a, b) => position.get(a) - position.get(b));
+  }
+  if (ordered.length < names.length) {
+    const placed = new Set(ordered);
+    for (const name of names) if (!placed.has(name)) ordered.push(name);
   }
   return ordered;
 }
 function referencedNames(value, aliases) {
   const seen = /* @__PURE__ */ new Set();
   const queue = directReferences(value);
-  while (queue.length > 0) {
-    const name = queue.shift();
+  for (let i = 0; i < queue.length; i += 1) {
+    const name = queue[i];
     if (seen.has(name)) continue;
     seen.add(name);
     const alias = aliases[name];
-    if (alias !== void 0) queue.push(...directReferences(alias));
+    if (alias !== void 0) for (const ref of directReferences(alias)) queue.push(ref);
   }
   return seen;
 }
@@ -1817,13 +1855,17 @@ var WS = UCP_SPACE;
 var S = `[${WS}]`;
 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 XN = "[xX][nN]--";
+var LABEL = `(?:${XN})?[\\p{L}\\p{N}]+(?:-[\\p{L}\\p{N}]+)*`;
+var TLD_LOWER = "\\p{Ll}\\p{Lm}\\p{Lo}";
+var TLD_UPPER = "\\p{Lu}\\p{Lt}\\p{Lm}\\p{Lo}";
+var TLD = `(?:${XN}[a-zA-Z0-9\\-\\u017F\\u212A]{2,59}|[${TLD_LOWER}][${TLD_LOWER}\\p{N}-]{1,62}|[${TLD_UPPER}][${TLD_UPPER}\\p{N}-]{1,62})`;
+var DOMAIN_PART = `(?:${LABEL}\\.)+${TLD}`;
 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 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 DOMAIN_AT_RE = new RegExp(`${DOMAIN_PART}${WORD_BOUNDARY}`, "uy");
+var DOMAIN_SCAN_RE = new RegExp(`${AFTER_NON_WORD}(?:(${DOMAIN_PART}${WORD_BOUNDARY})|(?:${LABEL}\\.)*${LABEL})`, "gu");
 var DECIMAL_RE = /\b\d+\.\d+\b/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");
@@ -1892,7 +1934,6 @@ function indexLeads(text) {
   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;
@@ -2021,7 +2062,7 @@ function postProcess(input) {
   text = text.replace(CAP_FIRST_RE, (_m, lead, ch) => lead + 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, afterBlockTag(), leadContext);
   text = capitalizeAfter(text, LOWER_RE, afterLineBreak, leadContext);
   return restore(text, input, placeholders).trim();
 }