@jackens/nnn 2026.8.24 → 2026.8.31

package/nnn.d.ts

@@ -64,43 +64,6 @@ export declare const c: (root: CRoot, splitter?: string) => string;
  * using the provided escape map.
  */
 export declare const createEscape: (escapeFn: (value: any) => string) => (template: TemplateStringsArray, ...values: unknown[]) => string;
-/**
- * Creates a function that
- * returns the appropriate noun form
- * based on a numeric value using `Intl.PluralRules`.
- *
- * Different languages have different plural rules.
- * The `Intl.PluralRules` API provides locale-aware
- * plural category selection.
- * Possible categories are:
- *
- * - `zero`: for zero items
- *   (used in some languages like Arabic, Latvian)
- * - `one`: for singular (e.g., 1 item)
- * - `two`: for dual
- *   (used in some languages like Arabic, Hebrew)
- * - `few`: for small plurals (e.g., 2-4 in Polish)
- * - `many`: for larger plurals (e.g., 5-21 in Polish)
- * - `other`: fallback category (used by all languages)
- *
- * @param locale
- *
- * A BCP 47 language tag (e.g., `pl`, `en`).
- *
- * @param forms
- *
- * An object mapping plural categories to noun forms.
- * Not all categories need to be provided;
- * if a category is missing,
- * the function falls back to `other`,
- * then to an empty string.
- *
- * @returns
- *
- * A function that takes a numeric value
- * and returns the appropriate noun form.
- */
-export declare const createPluralRules: (locale: string, forms: Partial<Record<Intl.LDMLPluralRule, string>>) => (value: number) => string;
 /**
  * A helper for building simple tokenizers
  * (see also {@link nanolightTs}).

package/nnn.js

@@ -6,6 +6,8 @@ var isString = (arg) => typeof arg === "string";
 var isRecord = (arg) => typeof arg === "object" && arg != null && !isArray(arg);
 
 // src/nnn/c.ts
+var DEFAULT_SPLITTER = "$$";
+var getName = (key, splitter = DEFAULT_SPLITTER) => key.split(splitter)[0].replace(/_/g, "-").replace(/([A-Z])/g, (_, letter) => "-" + letter.toLowerCase());
 var _c = (node, prefix, result, splitter) => {
   const queue = [[node, prefix]];
   while (queue.length > 0) {
@@ -18,19 +20,19 @@ var _c = (node, prefix, result, splitter) => {
       let attributesPushed = false;
       for (const key in style0) {
         const value = style0[key];
+        const name = getName(key, splitter);
         if (isString(value) || isNumber(value)) {
           if (!attributesPushed) {
             attributesPushed = true;
             attributes = [];
             todo.push([attributes, prefix0]);
           }
-          const attribute = key.split(splitter)[0].replace(/_/g, "-").replace(/([A-Z])/g, (_, letter) => "-" + letter.toLowerCase());
-          attributes.push(`${attribute}:${value}`);
+          attributes.push(`${name}:${value}`);
         } else if (value != null) {
           attributesPushed = false;
           const prefixN = [];
-          const keyChunks = key.split(",");
-          prefix0.split(",").forEach((prefixChunk) => keyChunks.forEach((keyChunk) => prefixN.push(prefixChunk + keyChunk)));
+          const nameChunks = name.split(",");
+          prefix0.split(",").forEach((prefixChunk) => nameChunks.forEach((nameChunk) => prefixN.push(prefixChunk + nameChunk)));
           todo.push([value, prefixN.join()]);
         }
       }
@@ -38,17 +40,18 @@ var _c = (node, prefix, result, splitter) => {
     }
   }
 };
-var c = (root, splitter = "$$") => {
+var c = (root, splitter = DEFAULT_SPLITTER) => {
   const chunks = [];
   for (const key in root) {
     const value = root[key];
+    const name = getName(key, splitter);
     if (value != null) {
       if (key[0] === "@") {
-        chunks.push(key.split(splitter)[0] + "{");
+        chunks.push(name + "{");
         _c(value, "", chunks, splitter);
         chunks.push("}");
       } else {
-        _c(value, key.split(splitter)[0], chunks, splitter);
+        _c(value, name, chunks, splitter);
       }
     }
   }
@@ -56,9 +59,6 @@ var c = (root, splitter = "$$") => {
 };
 // src/nnn/createEscape.ts
 var createEscape = (escapeFn) => (template, ...values) => String.raw(template, ...values.map(escapeFn));
-// src/nnn/createPluralRules.ts
-var PLURAL_RULES = {};
-var createPluralRules = (locale, forms) => (value) => forms[(PLURAL_RULES[locale] ??= new Intl.PluralRules(locale)).select(value)] ?? forms.other ?? "";
 // src/nnn/createTokenizer.ts
 var createTokenizer = (decorator, ...specs) => (code) => {
   const result = [];
@@ -358,7 +358,6 @@ var vivify = (ref) => _vivify({ _: ref }, "_");
 export {
   c,
   createEscape,
-  createPluralRules as createNounForm,
   createTokenizer,
   csvParse,
   fixPlTypography,

package/package.json

@@ -25,7 +25,6 @@
     "Monokai",
     "nanolight",
     "nnn",
-    "noun form",
     "omit",
     "pick",
     "Responsive Web Design",
@@ -44,5 +43,5 @@
   "name": "@jackens/nnn",
   "type": "module",
   "types": "nnn.d.ts",
-  "version": "2026.8.24"
+  "version": "2026.8.31"
 }

package/readme.md

@@ -1,6 +1,6 @@
 # nnn
 
-A collection of Jackens’ JavaScript helper utilities (version: `2026.8.24`).
+A collection of Jackens’ JavaScript helper utilities (version: `2026.8.31`).
 
 ## Installation
 
@@ -20,7 +20,6 @@ npm i @jackens/nnn
 import {
   c,
   createEscape,
-  createPluralRules,
   createTokenizer,
   csvParse,
   fixPlTypography,
@@ -64,10 +63,6 @@ import {
 - [`createEscape`](#createEscape):
   Creates a tag function
   for escaping interpolated values in template literals.
-- [`createPluralRules`](#createPluralRules):
-  Creates a function that
-  returns the appropriate noun form
-  based on a numeric value using `Intl.PluralRules`.
 - [`createTokenizer`](#createTokenizer):
   A helper for building simple tokenizers
   (see also [`nanolightTs`](#nanolightTs)).
@@ -466,79 +461,6 @@ const expected = `
 expect(actual).to.equal(expected)
 ```
 
-### createPluralRules
-
-```ts
-const createPluralRules: (locale: string, forms: Partial<Record<Intl.LDMLPluralRule, string>>) => (value: number) => string;
-```
-
-Creates a function that
-returns the appropriate noun form
-based on a numeric value using `Intl.PluralRules`.
-
-Different languages have different plural rules.
-The `Intl.PluralRules` API provides locale-aware
-plural category selection.
-Possible categories are:
-
-- `zero`: for zero items
-  (used in some languages like Arabic, Latvian)
-- `one`: for singular (e.g., 1 item)
-- `two`: for dual
-  (used in some languages like Arabic, Hebrew)
-- `few`: for small plurals (e.g., 2-4 in Polish)
-- `many`: for larger plurals (e.g., 5-21 in Polish)
-- `other`: fallback category (used by all languages)
-
-#### locale
-
-A BCP 47 language tag (e.g., `pl`, `en`).
-
-#### forms
-
-An object mapping plural categories to noun forms.
-Not all categories need to be provided;
-if a category is missing,
-the function falls back to `other`,
-then to an empty string.
-
-#### Returns
-
-A function that takes a numeric value
-and returns the appropriate noun form.
-
-#### Usage Examples
-
-```ts
-const auto = createPluralRules('pl', {
-  one: 'auto',
-  few: 'auta',
-  other: 'aut',
-})
-
-expect(auto(0)).to.equal('aut')
-expect(auto(1)).to.equal('auto')
-expect(auto(17)).to.equal('aut')
-expect(auto(42)).to.equal('auta')
-
-const car = createPluralRules('en', {
-  one: 'car',
-  other: 'cars',
-})
-
-expect(car(0)).to.equal('cars')
-expect(car(1)).to.equal('car')
-expect(car(17)).to.equal('cars')
-expect(car(42)).to.equal('cars')
-
-const empty = createPluralRules('en', {})
-
-expect(empty(0)).to.equal('')
-expect(empty(1)).to.equal('')
-expect(empty(17)).to.equal('')
-expect(empty(42)).to.equal('')
-```
-
 ### createTokenizer
 
 ```ts