@spintax/core 0.9.0 → 0.11.0

package/CHANGELOG.md

@@ -3,6 +3,97 @@
 All notable changes to `@spintax/core` are documented here. This project adheres to
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 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
+
+- **No space between a punctuation mark and the quote or bracket that closes it.** The spacing passes
+  put their space after `.!?` and `,;:` whenever the next character was not a space, a digit, a tag or
+  the end — so a closing quote or bracket got one in front of it: `"Is it audited? ", the figure`,
+  `He called it "the best. "`, `She said "yes, " and left`, `«Как дела? », и ушёл`, `(really? )`,
+  `(apples, pears, etc. )`. Found in a landing lead that quotes a question-shaped keyword; every engine
+  in the family did the same. Now no space goes between the mark and a closer, and what follows the
+  closer is left as written. `)` and `]` always close (a stray `]` stays literal). A quote is read by
+  what follows its run, because its shape says nothing — `“` opens English and closes German, `"` and `'`
+  do both: whitespace, the end, a tag, the end of a tag (`title="Really?">`), `.,;:!?…`, `)`, `]` or a
+  dash make it a closer. Anything else keeps the space it always got — a word or a number
+  (`Is it?"Next"` → `Is it? "Next"`), `(`, `$`, a shielded value. The accepted cost: an opening quote
+  glued to the mark whose text starts with a follower (`is it?"—no"`, `is it?"<em>yes</em>"`) reads as a
+  closer and loses that space. Both PHP engines take the same rule.
+
+### Corpus
+
+Nineteen new cases in `render-postprocess.json`, every expectation taken from both PHP engines with the
+rule applied: the reported shapes (`postprocess/closing-quote-after-question`, `closing-quote-before-space`,
+`closing-typographic-quote-after-exclamation`, `closing-single-quote`), the rest of the class
+(`closing-quote-after-period-at-end-of-text`, `closing-quote-after-comma`, `closing-guillemet-ru`,
+`closing-quote-ends-attribute`, `closing-bracket`, `closing-square-bracket`, `closing-quote-before-tag`,
+`closing-run-of-nested-quotes`, `bracket-always-closes`), `closing-quote-followers` and
+`closing-reversed-quotes-and-more-followers` (between them every quote as a closer and every follower),
+the cost `glued-opener-before-a-follower-reads-as-closer`, and three guards —
+`opening-quote-after-sentence-keeps-space` (a quote or a run of quotes before a letter or a digit still
+opens), `quote-before-anything-else-keeps-its-space` (`(`, `$`) and `quote-before-shielded-value-opens`.
+
+### Notes
+
+**The list names what follows a CLOSING quote.** The first version of the rule excluded instead — any
+quote run not followed by a letter, a digit or a placeholder closed. That also took the space from an
+opening quote glued to the mark before `(`, `$` or an emoji (`is it?"(really)"`), which the old rule had
+repaired (found by the Codex gate, as were the attribute case and the stray `]`). A list changes output
+only where the quote is known to close, and an unnamed shape keeps the old output. Left as it was: a
+bracket that arrives through `neutralize()` is a sentinel during this stage and is restored after it, so a
+neutralized `[sic.]` still renders `[sic. ]`.
+
+**Verified.** 143 968 generated post-process inputs — random soup over letters, digits, whitespace,
+`.,;:!?…`, every quote and bracket, tags and shieldable values, plus an exhaustive grid of mark × quote run
+× follower — through this engine and both patched PHP engines: identical everywhere. The three agreed
+before the change as well, and every one of the 66 988 outputs that moved differs from the old output only
+by a deleted space between a mark and a closer. Thirty control mutations, one per character of the rule —
+each quote dropped, each follower dropped (including whitespace, the end, a tag, `/>` and `>`), `)` or `]`
+no longer closing, the comma pass left alone, and the first version's letter-or-digit rule — each turn the
+differential red (363 to 25 905 inputs) and fail at least one fixture. Cost unchanged here and in PHP:
+200 000 marks before 200 000 quotes take single-digit milliseconds in all three.
+
 ## 0.9.0 — 2026-09-17
 
 ### Changed, visibly

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 386 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":
@@ -1795,10 +1804,11 @@ function joinWithSeparators(elements, globalSep, globalLastsep) {
   }
   return joinFragments(pieces);
 }
+var UNSPACED_SCRIPT_RE = /^[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}ーｰ]+$/u;
 function padSeparator(sep) {
   const trimmed = phpTrim(sep);
   if (trimmed === "") return sep;
-  if (/^\p{L}+$/u.test(trimmed)) return ` ${trimmed} `;
+  if (/^\p{L}+$/u.test(trimmed) && !UNSPACED_SCRIPT_RE.test(trimmed)) return ` ${trimmed} `;
   return sep;
 }
 
@@ -1911,9 +1921,11 @@ function trailingPunctuationStart(value) {
 }
 var SENTENCE_OPENERS = "\xBF\xA1";
 var LEAD = `(?:<[^>]+>|[${SENTENCE_OPENERS}]|${S})*`;
+var QUOTES = `"'\xAB\xBB\u2039\u203A\u201C\u201D\u2018\u2019`;
+var CLOSER = `[)\\]]|[${QUOTES}]+(?=${S}|$|<|\\/?>|[.,;:!?\u2026)\\]\u2014\u2013])`;
 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_COMMA_RE = new RegExp(`([,;:])(?!\\p{Nd})(?!${S}|$|<|${CLOSER})`, "gu");
+var SPACE_AFTER_SENTENCE_RE = new RegExp(`(?<![.!?])([.!?]+)(?![.!?])(?!\\p{Nd})(?!${S}|$|<|${CLOSER})`, "gu");
 var SPACE_AFTER_OPENER_RE = new RegExp(`([${SENTENCE_OPENERS}])${S}+`, "gu");
 var CAP_FIRST_RE = new RegExp(`^(${LEAD})(\\p{Ll})`, "u");
 var up = (ch) => ch.toUpperCase();