@spintax/core 0.10.0 → 0.12.0

package/CHANGELOG.md

@@ -3,6 +3,86 @@
 All notable changes to `@spintax/core` are documented here. This project adheres to
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.12.0 — 2026-10-06
+
+A minor: rendered text moves for permutation separators in Arabic, Hebrew, Thai and Lao. No verdict
+changes and no API change; `render()` already took the `locale` it now also reads here.
+
+### Fixed
+
+- **An Arabic list can be written (#90).** The conjunction و ("and") — and ف ("and then") — is written
+  attached to the next word: `الكازينو والبث`, never `الكازينو و البث`. A letter-only separator was always
+  padded on both sides, whatever spaces the author wrote, so no shape of `lastsep` could produce it. Now,
+  under `locale: 'ar'`, a separator that is exactly و or ف keeps the space before it and none after when
+  the next element starts with an Arabic letter: `[<sep="، ";lastsep="و">…]` renders
+  `الكازينو، المراهنات الرياضية والبث المباشر`. Before anything else — a Latin brand name, a digit — both
+  spaces stay: `و Evolution`. Hebrew ו under `locale: 'he'` works the same way. The rule is keyed by
+  LANGUAGE, not script: Persian and Urdu write the same letter و as a word of its own, so under `fa` and
+  `ur` it is padded as before, and so is every word conjunction (أو, ثم, או) and و with no locale.
+- **Thai and Lao separators join bare (#90),** as Han and kana have since 0.11.0: `[<lastsep="และ">แมว|สุนัข]`
+  renders `แมวและสุนัข`. Khmer and Myanmar take the same rule. A separator carrying a combining mark —
+  Thai `หรือ`, most Khmer and Myanmar words — is not all letters, so it was never padded and still renders
+  exactly as written, spaces included.
+
+No template in the family's stored content uses any of these separators (measured over casino-platform,
+content-gen, both sites and the plugin: the only hits were the probes that found the issue), so no
+existing text changes.
+
+### Corpus
+
+408 cases (+22), all in `render-semantics.json`. `perm/sep-arabic-*` (و and ف attached, the author's
+spaces, a regional locale, before a Latin word, a digit, an astral Arabic letter and U+0640, a word
+conjunction, the issue's whole list with the post-process on), `perm/sep-persian-waw-padded`,
+`perm/sep-urdu-waw-padded`, `perm/sep-waw-without-locale-padded`, `perm/sep-hebrew-*` (ו attached, before a Latin word, the word conjunction או), `perm/sep-thai-*`,
+`perm/sep-lao-not-padded`, `perm/sep-khmer-not-padded`, `perm/sep-myanmar-not-padded`, and
+`perm/sep-script-not-script-extensions`.
+
+That last one pins a divergence 0.11.0 shipped in both PHP engines without anyone seeing it: PCRE2 10.40
+and later read `\p{Han}` as Script_Extensions, so U+3006 〆, U+303C 〼, the kana repeat marks U+3031–3035
+and the halfwidth sound marks U+FF9E/FF9F joined bare there and were padded here and in every port. The
+PHP engines now exclude them, which is Script on any PCRE2 version. The same trap sat under the new Arabic
+test (U+0640, tatweel); the next element is read by code point, not by UTF-16 unit.
+
+## 0.11.0 — 2026-10-03
+
+A minor: one verdict changes (a two-form `ar` plural is now an error) and rendered text moves for
+Arabic plurals and for CJK list separators.
+
+### Added
+
+- **Arabic plurals (#88).** `pluralArity('ar')` is **6**, and `{plural …}` picks in CLDR order:
+  zero (0), one (1), two (2), few (n % 100 in 3..10), many (n % 100 in 11..99), other (everything
+  else — 100–102, 200–202, …). Negative counts use `abs()` as before; counts are integers, so CLDR's
+  fraction rules cannot be reached. Arabic used to get the English rule — `forms[0]` for 1,
+  `forms[1]` for everything else — which is ungrammatical for most counts, and a correct six-form
+  block was a `plural.arity` error, so there was no way to write one.
+  **The arity is strict, like every other locale's: a two-form `ar` block is now `plural.arity`**
+  and renders as the fullwidth fallback. Accepting two as a fallback would keep the silent
+  ungrammatical output. `DEFAULT_PLURAL_ARITY` (no locale) stays 2.
+
+### Fixed
+
+- **A Chinese or Japanese list separator joins without spaces (#87).** A separator made only of
+  letters is space-padded on join (`[<lastsep="and">A|B]` → `A and B`), and that was applied to
+  scripts written without spaces between words: `[<lastsep="和">SSO|告警]` printed `SSO 和 告警`. Now a
+  separator whose every letter is Han, Hiragana or Katakana — plus the prolonged-sound marks U+30FC
+  and U+FF70, which are Script=Common but written inside Katakana words — joins bare: `SSO和告警`,
+  `SSOおよび監視`. Hangul keeps the padding (Korean spaces its words), and so does a separator that
+  mixes scripts (`and和`). Thai, Lao, Khmer and Myanmar are also written without spaces and are left
+  as they were until a template in them shows up.
+
+### Corpus
+
+386 cases (+34). `plural/ar-*` at 0, 1, 2, 3, 10, 11, 99, 100, 101, 102, 103, 111 and −3, a real
+noun under `ar-EG`, and the two-form fallback; `validate/plural-ar-{six-forms-valid,two-forms-invalid,
+three-forms-invalid}`; `perm/sep-{han,kana,katakana-prolonged-mark,halfwidth-katakana}-not-padded`,
+`perm/sep-hangul-padded`, `perm/sep-mixed-script-padded`. Two more groups move no TS output and pin
+what other engines got wrong: digits-only definition names (`def/digits-only-*`, `set/digits-only-name`
+and the `%0%`/`%07%` controls — #84, PHP lost the value to integer-key coercion) and `extract`'s refs
+(`extract/ref-inside-{set,def}-value`, `extract/def-name-not-a-phantom-ref`,
+`extract/conditional-ref-inside-set-value`, `extract/definition-lhs-after-line-separator` — #83, the PHP runners scanned a different body). Every
+expectation was written by hand and checked against both PHP engines with their mirrors applied.
+
 ## 0.10.0 — 2026-09-19
 
 ### Fixed

package/README.md

@@ -19,7 +19,7 @@ parse, render, validate, extract, analyze, and neutralize spintax templates.
   [`spintax-core`](https://pypi.org/project/spintax-core/) (Python), an Object Pascal engine,
   [`Spintax.Core`](https://www.nuget.org/packages/Spintax.Core/) (.NET), and
   the [Spintax WordPress plugin](https://wordpress.org/plugins/spintax/) are all held to the same
-  behavior contract by a **shared golden corpus of 258 fixtures** — deterministic verdicts, plural
+  behavior contract by a **shared golden corpus of 408 fixtures** — deterministic verdicts, plural
   buckets, conditionals, `#set`/`#def` semantics and post-processing agree everywhere, so a
   template is an asset you can move between runtimes, not a lock-in.
 - **MIT** licensed.
@@ -85,7 +85,7 @@ dedupe in the host and cap the retries: a template may simply not have N combina
 | Local set | `#set %v% = value` | define a macro — re-picked at every use |
 | Local def | `#def %v% = value` | define a value — picked once per render, held at every use |
 | Conditional | `{?VAR?then\|else}` | `then` if `VAR` is truthy, else `else` — inside `{…}`/`[…]` it resolves first, so a `\|` in the taken branch separates options and an empty one drops its element |
-| Plural | `{plural %n%: one\|few\|many}` | grammatical agreement by locale |
+| Plural | `{plural %n%: one\|few\|many}` | grammatical agreement by locale — 2 forms (en), 3 (ru/uk/be, sr/hr/bs), 6 (ar: zero\|one\|two\|few\|many\|other) |
 | Include | `#include "slug-or-id"` | embed another template (host-resolved) |
 | Comment | `/# … #/` | stripped before rendering |
 
@@ -103,7 +103,7 @@ capitalization, URL/email shielding) is **on by default**.
 render(input, {
   context?:         Record<string, string>,   // variable map
   seed?:            number | string,           // deterministic RNG; omit ⇒ random
-  locale?:          string,                     // plural buckets, e.g. 'ru' (3-form)
+  locale?:          string,                     // plural buckets: 'ru' 3-form, 'ar' 6-form
   includeResolver?: (ref: string) => string | null,  // host-injected, synchronous
   postProcess?:     boolean,                    // default true; false ⇒ raw pick
   maxDepth?:        number,                      // #include / nesting guard (default 20)

package/dist/index.cjs

@@ -744,6 +744,8 @@ function normalizeBaseLang(locale) {
 }
 function pluralArity(baseLang) {
   switch (baseLang) {
+    case "ar":
+      return 6;
     case "ru":
     case "uk":
     case "be":
@@ -761,6 +763,13 @@ function pluralFor(baseLang, n, forms) {
   const mod10 = abs % 10;
   const mod100 = abs % 100;
   switch (baseLang) {
+    case "ar":
+      if (abs === 0) return forms[0] ?? "";
+      if (abs === 1) return forms[1] ?? "";
+      if (abs === 2) return forms[2] ?? "";
+      if (mod100 >= 3 && mod100 <= 10) return forms[3] ?? "";
+      if (mod100 >= 11) return forms[4] ?? "";
+      return forms[5] ?? "";
     case "ru":
     case "uk":
     case "be":
@@ -1380,6 +1389,37 @@ function trimFragment(fragment) {
   if (fragment.lead === 0 && fragment.trail === 0) return fragment;
   return new Window(fragment, fragment.lead, fragment.length - fragment.trail);
 }
+function firstCodePointOf(fragment) {
+  const hi = charCodeAtOf(fragment, 0);
+  if (hi >= 55296 && hi <= 56319) {
+    const lo = charCodeAtOf(fragment, 1);
+    if (lo >= 56320 && lo <= 57343) return (hi - 55296) * 1024 + (lo - 56320) + 65536;
+  }
+  return hi;
+}
+function charCodeAtOf(fragment, index) {
+  let piece = fragment;
+  let at = index;
+  for (; ; ) {
+    if (at < 0 || at >= lengthOf(piece)) return -1;
+    if (typeof piece === "string") return piece.charCodeAt(at);
+    if (piece instanceof Window) {
+      at += piece.from;
+      piece = piece.base;
+      continue;
+    }
+    let offset = 0;
+    for (const child of piece.pieces) {
+      const length = lengthOf(child);
+      if (at < offset + length) {
+        piece = child;
+        at -= offset;
+        break;
+      }
+      offset += length;
+    }
+  }
+}
 function flatten(fragment) {
   if (typeof fragment === "string") return fragment;
   const out = [];
@@ -1773,7 +1813,12 @@ function assemblePermutation(node, rendered, opts) {
   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);
+  return joinWithSeparators(
+    elements.slice(0, pick),
+    config.sep,
+    config.lastsep ?? config.sep,
+    normalizeBaseLang(opts.locale)
+  );
 }
 function shuffle(arr, rng) {
   for (let i = arr.length - 1; i > 0; i -= 1) {
@@ -1783,7 +1828,7 @@ function shuffle(arr, rng) {
     arr[j] = tmp;
   }
 }
-function joinWithSeparators(elements, globalSep, globalLastsep) {
+function joinWithSeparators(elements, globalSep, globalLastsep, lang) {
   const count = elements.length;
   if (count === 0) return "";
   if (count === 1) return elements[0].text;
@@ -1791,14 +1836,24 @@ function joinWithSeparators(elements, globalSep, globalLastsep) {
   for (let i = 1; i < count; i += 1) {
     const el = elements[i];
     const sep = el.sep ?? (i === count - 1 ? globalLastsep : globalSep);
-    pieces.push(padSeparator(sep), el.text);
+    pieces.push(padSeparator(sep, lang, el.text), el.text);
   }
   return joinFragments(pieces);
 }
-function padSeparator(sep) {
+var UNSPACED_SCRIPT_RE = /^[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}ーｰ\p{Script=Thai}\p{Script=Lao}\p{Script=Khmer}\p{Script=Myanmar}]+$/u;
+var PROCLITICS = /* @__PURE__ */ new Map([
+  ["ar", { words: /* @__PURE__ */ new Set(["\u0648", "\u0641"]), letter: /^(?=\p{L})\p{Script=Arabic}$/u }],
+  ["he", { words: /* @__PURE__ */ new Set(["\u05D5"]), letter: /^(?=\p{L})\p{Script=Hebrew}$/u }]
+]);
+function padSeparator(sep, lang, next) {
   const trimmed = phpTrim(sep);
   if (trimmed === "") return sep;
-  if (/^\p{L}+$/u.test(trimmed)) return ` ${trimmed} `;
+  const proclitic = PROCLITICS.get(lang);
+  if (proclitic !== void 0 && proclitic.words.has(trimmed)) {
+    const first = firstCodePointOf(next);
+    return first >= 0 && proclitic.letter.test(String.fromCodePoint(first)) ? ` ${trimmed}` : ` ${trimmed} `;
+  }
+  if (/^\p{L}+$/u.test(trimmed) && !UNSPACED_SCRIPT_RE.test(trimmed)) return ` ${trimmed} `;
   return sep;
 }