@johnmorrisdotca/kumimoji 1.3.0 → 1.4.0

package/CHANGELOG.md

@@ -6,6 +6,26 @@ All notable changes to this project are written down here. The format follows
 
 ## [Unreleased]
 
+## [1.4.0] - 2026-11-02
+
+### Added
+
+- A table can be laid in the family's five cloths: `<kumimoji-table cloth="blue">`, `mountKumimoji(el, { cloth })` and `set({ cloth })`, the `cloth` embed parameter and Builder option, and `KUMIMOJI_CLOTHS`, `isCloth` and `clothVars` from `/ui`. The demo's header patches lay it through the page's theme.
+
+- **`checkKumimoji` gives its reason as a code and values as well as in English.** A refusal is now `{ ok: false, reason, code, values }`: `reason` is the sentence it has always been, word for word, and `code` (`"no-hand"`, `"givens-not-bag"`, `"wild-count-wrong"`, `"bag-exceeds-set"`, `"answer-not-grid"`, `"grid-not-the-bag"`, `"tiles-apart"`, `"not-a-word"` and `"grid-not-finished"`) and `values` (`{ size }` for `no-hand`, `{ word }` for `not-a-word`) let a site say it in its own language. `KUMIMOJI_CHECK_REASONS` lists every code with its English clause, `kumimojiRefusal(code, values)` makes a refusal, and the types are `KumimojiCheckCode` and `KumimojiCheckValues`. A test holds every refusal's `reason` to its code's clause filled with its values.
+
+## [1.3.1] - 2026-10-31
+
+### Changed
+
+- Biome replaces ESLint as the formatter and linter, with the family's shared settings in `scripts/biome-family.json`; `pnpm lint` checks formatting too, and `pnpm format` applies it. The code is formatted once to 120 columns. Nothing a user of the package sees has changed.
+- TypeScript targets ES2022, treats an indexed read as possibly missing, and refuses switch fallthrough and unmarked overrides.
+- `pnpm check` also holds every source file to at most 500 lines of code (`scripts/check-size.mjs`; blank lines, comments, tests and data files are not counted).
+
+### Fixed
+
+- The issue chooser's security link shows again: an unquoted colon had made `.github/ISSUE_TEMPLATE/config.yml` invalid YAML.
+
 ## [1.3.0] - 2026-10-14
 
 The table is a custom element with the family's standard embed attributes and a shared builder, and the package has an English and Japanese documentation site with a checked example for every export. The rules, generation, seeds and saved games are unchanged.
@@ -176,7 +196,8 @@ The first release.
   `@johnmorrisdotca/kumimoji/react`.
 - A static demo for GitHub Pages.
 
-[Unreleased]: https://github.com/johnmorrisdotca/kumimoji/compare/v1.3.0...HEAD
+[Unreleased]: https://github.com/johnmorrisdotca/kumimoji/compare/v1.4.0...HEAD
+[1.4.0]: https://github.com/johnmorrisdotca/kumimoji/compare/v1.3.1...v1.4.0
 [1.3.0]: https://github.com/johnmorrisdotca/kumimoji/compare/v1.2.2...v1.3.0
 [1.2.1]: https://github.com/johnmorrisdotca/kumimoji/compare/v1.2.0...v1.2.1
 [1.1.1]: https://github.com/johnmorrisdotca/kumimoji/compare/v1.1.0...v1.1.1

package/CONTRIBUTING.md

@@ -21,7 +21,8 @@ shape before you spend time on it. Taking part follows the
 
 ```sh
 pnpm install
-pnpm check          # lint, types and tests: the same as CI
+pnpm check          # format, lint, types, file sizes and tests: the same as CI
+pnpm format         # format the code and apply the safe lint fixes
 pnpm test:package   # pack it as npm does, install it in an empty project, import every entry
 pnpm site           # build the demo into ./site, as GitHub Pages publishes it
 ```
@@ -31,12 +32,18 @@ data scripts) are listed under its own heading below.
 
 ## House rules, shared by every package of the family
 
+How the code is written, formatted and checked, and why, is in
+[CODE-STYLE.md](CODE-STYLE.md), the same text in every package.
+
 - **No runtime dependencies.** Development dependencies are for tests, builds and
   documentation only.
 - **The core is pure.** Every function in it returns new values and never
   changes what it was given.
 - **Test what you change.** Tests sit beside the code they test. A rule you
   change has a test that would have caught it.
+- **At most 500 lines of code a file** under `src/`, not counting blank lines,
+  comments, tests or `*.data.ts` data. A file that reaches it is split by what
+  it does, never squeezed.
 - **Words a person reads come in English and Japanese.** If you cannot write the
   Japanese, say so in the pull request and someone will.
 - **Option values and names are kebab case.**
@@ -48,7 +55,9 @@ data scripts) are listed under its own heading below.
   together with the code.
 - **The family's own files are the same in every package**: `demo/family.css`,
   `scripts/family-template.mjs`, `scripts/family-readme.mjs`,
-  `scripts/release-notes.mjs`, the files in `scripts/community/` and
+  `scripts/release-notes.mjs`, the files in `scripts/community/`,
+  `CODE-STYLE.md`, `scripts/biome-family.json`, `scripts/check-size.mjs`,
+  `src/embed-attributes.ts` where the package has an element, and
   `family.test.js` (in `src/`, or in `test/`). Do not edit one here. To change
   one, change it in every repository at once, bump `FAMILY_TEMPLATE_VERSION` for
   the template, and record the new hash in `family.test.js`. What is the

package/README.md

@@ -10,7 +10,7 @@ In English and in Japanese kana. The rules as pure, seeded TypeScript, two word
   <a href="./NOTICE.md"><img alt="Japanese word list: CC BY-SA 4.0" src="https://img.shields.io/badge/Japanese%20words-CC%20BY--SA%204.0-b5452c"></a>
   <img alt="No dependencies" src="https://img.shields.io/badge/dependencies-0-2f5d4a">
   <img alt="TypeScript" src="https://img.shields.io/badge/types-TypeScript-3178c6">
-  <a href="https://johnmorrisdotca.github.io/kumimoji/docs/api/main/index.html"><img alt="679.1 kB minified and gzipped" src="https://img.shields.io/badge/min%2Bgzip-679.1%20kB-2f5d4a"></a>
+  <a href="https://johnmorrisdotca.github.io/kumimoji/docs/api/main/index.html"><img alt="679.3 kB minified and gzipped" src="https://img.shields.io/badge/min%2Bgzip-679.3%20kB-2f5d4a"></a>
   <a href="https://www.npmjs.com/package/@johnmorrisdotca/kumimoji#provenance"><img alt="Published with npm provenance" src="https://img.shields.io/badge/npm-provenance-2f5d4a"></a>
 </p>
 
@@ -242,7 +242,7 @@ const wrong = decodeGrid("cat/2x")!;
 judgeWithWords(wrong, words).notWords; // → ["tx"]
 
 checkKumimoji(3, "nwosy", "snowy", { level: "hard" }); // → { ok: true }
-checkKumimoji(3, "nwosy", "snows", { level: "hard" }); // → { ok: false, reason: "the grid does not use exactly the tiles of the bag" }
+checkKumimoji(3, "nwosy", "snows", { level: "hard" }); // → { ok: false, reason: "the grid does not use exactly the tiles of the bag", code: "grid-not-the-bag" }
 encodeGrid(tiles); // → "cat/2o/2w"
 ```
 
@@ -541,7 +541,7 @@ import { checkKumimoji, generateKumimoji, loadTileWords } from "@johnmorrisdotca
 await loadTileWords("english");
 const dealt = generateKumimoji(3, "hard", 44);
 checkKumimoji(3, dealt.givens, "snowy", { level: "hard" }); // → { ok: true }
-checkKumimoji(3, dealt.givens, "snows", { level: "hard" }); // → { ok: false, reason: "the grid does not use exactly the tiles of the bag" }
+checkKumimoji(3, dealt.givens, "snows", { level: "hard" }); // → { ok: false, reason: "the grid does not use exactly the tiles of the bag", code: "grid-not-the-bag" }
 ```
 
 ### Mount the table with options
@@ -566,6 +566,8 @@ table.destroy();
 
 ### A look of your own
 
+`<kumimoji-table cloth="blue">`, or `cloth: "blue"` when you mount, lays the table in one of the family's five cloths, `green`, `blue`, `red`, `black` or `wood`, the same set as the boards on itsutsu.com; `set({ cloth })` changes it in place, keeping the game, and `theme` is laid over it. `KUMIMOJI_CLOTHS` and `clothVars` hold the colours.
+
 Every colour is a CSS variable on `.km-root`, so a stylesheet or the `theme` option can restyle the table:
 
 ```ts no-run
@@ -768,7 +770,7 @@ The JSON, as `kumimojiToJSON` writes it:
 {
   "format": 1,
   "game": "kumimoji",
-  "generator": "kumimoji 1.3.0",
+  "generator": "kumimoji 1.4.0",
   "size": 3,
   "level": "hard",
   "seed": 44,
@@ -886,23 +888,14 @@ as you type. The entries:
 | `deal(bag, handSize)` and `placeFromHand`, `moveOnTable`, `liftToHand`, `draw`, `trade` | The opening hand, and each move, every one returning a new game |
 | `judgeWithWords(tiles, words)` | What is wrong with a grid, or that it is sound |
 | `isFinished(play, verdict)` | Whether the bag is empty, the hand used and every run a word in one piece |
-| `checkKumimoji(size, givens, answer, options?)` | The one check a server runs on a finished grid |
+| `checkKumimoji(size, givens, answer, options?)` | The one check a server runs on a finished grid; a refusal has `reason`, `code`, `values` (`KUMIMOJI_CHECK_REASONS`, `kumimojiRefusal`) |
 | `loadTileWords(language)` | A word list, fetched when first needed |
 | `mountKumimoji(element, options?)` and `<kumimoji-table>` | The table, in one call or one tag |
 | `kumimojiToJSON`, `kumimojiFromJSON` | A game kept, and read back without trusting it |
 
 ### The long tables
 
-The tables of every export for dealing and judging, tiles and grids, playing and keeping a game, a table of players and looking at the table are in [docs/API.md](docs/API.md), and every export of every entry point, with its signature and doc comment, is in the [API reference](https://johnmorrisdotca.github.io/kumimoji/api.html). The types the package exports are listed there too.
-
-The types are `TilePlay`, `Tiles`, `GridVerdict`, `GridRules`, `Run`,
-`RunLine`, `Bounds`, `Square`, `CrossingFit`, `KumimojiDeal`,
-`KumimojiOptions`, `KumimojiCheck`, `KumimojiLevel`, `KumimojiLength`,
-`KumimojiLanguage`, `TileWords`, `TileFaceOf`, `PartyGame`, `PartySettings`,
-`PartyPlayer`, `PartySeat`, `PartyEnding`, `JoinRefusal`, `LeaveRefusal`,
-`ComputerStep`, `ComputerSaid`, `KumimojiSaved`, `KumimojiExported`, `KumimojiStrings`,
-`KumimojiLocale`, `Random`, `Turn`, `Area`, `View`, `MixTile`, `MixShown` and
-`LengthRow`.
+The types, and the tables of every export for dealing and judging, tiles and grids, playing and keeping a game, a table of players and looking at the table are in [docs/API.md](docs/API.md), and every export of every entry point, with its signature and doc comment, is in the [API reference](https://johnmorrisdotca.github.io/kumimoji/api.html). The types the package exports are listed there too.
 
 ### The table
 
@@ -1201,7 +1194,7 @@ Please follow the [code of conduct](./CODE_OF_CONDUCT.md). A way to make a check
 
 See [CHANGELOG.md](./CHANGELOG.md).
 
-The latest release is 1.3.0: the table's standard embed attributes, the shared embed builder, and the documentation site with a checked example for every export.
+The latest release, 1.4.0, gives a check's reason as a code beside the English, and lets a table be laid in the family's five cloths.
 
 ## Licence
 

package/dist/check-reasons.d.ts

@@ -0,0 +1,71 @@
+import type { KumimojiCheck } from "./kumimoji.types.ts";
+/**
+ * Why `checkKumimoji` will not take a grid, as a stable code and the English clause it says: `{name}` is a gap the
+ * check's `values` fill. The clause is what `reason` has always said, word for word; a site that speaks another
+ * language says the code in its own words and puts the values in the gaps.
+ *
+ * | Code | Values |
+ * | --- | --- |
+ * | `no-hand` | `size`: the hand that has no game |
+ * | `not-a-word` | `word`: the first word that is not in the word list |
+ * | `givens-not-bag`, `wild-count-wrong`, `bag-exceeds-set`, `answer-not-grid`, `grid-not-the-bag`, `tiles-apart`, `grid-not-finished` | none |
+ *
+ * @example
+ * ```ts
+ * import { KUMIMOJI_CHECK_REASONS } from "@johnmorrisdotca/kumimoji";
+ *
+ * console.log(KUMIMOJI_CHECK_REASONS["not-a-word"]);
+ * ```
+ */
+export declare const KUMIMOJI_CHECK_REASONS: {
+    readonly "no-hand": "no Kumimoji with a hand of {size}";
+    readonly "givens-not-bag": "the givens are not a bag of tiles";
+    readonly "wild-count-wrong": "the bag has the wrong number of wild tiles";
+    readonly "bag-exceeds-set": "the bag exceeds the tile set";
+    readonly "answer-not-grid": "the answer is not a grid";
+    readonly "grid-not-the-bag": "the grid does not use exactly the tiles of the bag";
+    readonly "tiles-apart": "the tiles are not all joined";
+    readonly "not-a-word": "{word} is not in the word list";
+    readonly "grid-not-finished": "the grid is not finished";
+};
+/**
+ * A reason `checkKumimoji` can give, by its stable code.
+ *
+ * @example
+ * ```ts
+ * import type { KumimojiCheckCode } from "@johnmorrisdotca/kumimoji";
+ *
+ * const code: KumimojiCheckCode = "tiles-apart";
+ * console.log(code);
+ * ```
+ */
+export type KumimojiCheckCode = keyof typeof KUMIMOJI_CHECK_REASONS;
+/**
+ * The numbers and words that fill a reason's gaps, by the gap's name (see `KUMIMOJI_CHECK_REASONS` for each code's).
+ *
+ * @example
+ * ```ts
+ * import type { KumimojiCheckValues } from "@johnmorrisdotca/kumimoji";
+ *
+ * const values: KumimojiCheckValues = { word: "aow" };
+ * console.log(values);
+ * ```
+ */
+export type KumimojiCheckValues = Readonly<Record<string, string | number>>;
+/**
+ * A refusal: `{ ok: false }`, the English `reason` (the clause of the code with the values in its gaps), the code
+ * and the values.
+ *
+ * @param code - Why the grid is not taken.
+ * @param values - What fills the clause's gaps, where it has any.
+ * @returns The refusal `checkKumimoji` gives.
+ * @example
+ * ```ts
+ * import { kumimojiRefusal } from "@johnmorrisdotca/kumimoji";
+ *
+ * console.log(kumimojiRefusal("not-a-word", { word: "aow" }));
+ * ```
+ */
+export declare function kumimojiRefusal(code: KumimojiCheckCode, values?: KumimojiCheckValues): Extract<KumimojiCheck, {
+    ok: false;
+}>;

package/dist/check-reasons.js

@@ -0,0 +1,47 @@
+/**
+ * Why `checkKumimoji` will not take a grid, as a stable code and the English clause it says: `{name}` is a gap the
+ * check's `values` fill. The clause is what `reason` has always said, word for word; a site that speaks another
+ * language says the code in its own words and puts the values in the gaps.
+ *
+ * | Code | Values |
+ * | --- | --- |
+ * | `no-hand` | `size`: the hand that has no game |
+ * | `not-a-word` | `word`: the first word that is not in the word list |
+ * | `givens-not-bag`, `wild-count-wrong`, `bag-exceeds-set`, `answer-not-grid`, `grid-not-the-bag`, `tiles-apart`, `grid-not-finished` | none |
+ *
+ * @example
+ * ```ts
+ * import { KUMIMOJI_CHECK_REASONS } from "@johnmorrisdotca/kumimoji";
+ *
+ * console.log(KUMIMOJI_CHECK_REASONS["not-a-word"]);
+ * ```
+ */
+export const KUMIMOJI_CHECK_REASONS = {
+    "no-hand": "no Kumimoji with a hand of {size}",
+    "givens-not-bag": "the givens are not a bag of tiles",
+    "wild-count-wrong": "the bag has the wrong number of wild tiles",
+    "bag-exceeds-set": "the bag exceeds the tile set",
+    "answer-not-grid": "the answer is not a grid",
+    "grid-not-the-bag": "the grid does not use exactly the tiles of the bag",
+    "tiles-apart": "the tiles are not all joined",
+    "not-a-word": "{word} is not in the word list",
+    "grid-not-finished": "the grid is not finished",
+};
+/**
+ * A refusal: `{ ok: false }`, the English `reason` (the clause of the code with the values in its gaps), the code
+ * and the values.
+ *
+ * @param code - Why the grid is not taken.
+ * @param values - What fills the clause's gaps, where it has any.
+ * @returns The refusal `checkKumimoji` gives.
+ * @example
+ * ```ts
+ * import { kumimojiRefusal } from "@johnmorrisdotca/kumimoji";
+ *
+ * console.log(kumimojiRefusal("not-a-word", { word: "aow" }));
+ * ```
+ */
+export function kumimojiRefusal(code, values) {
+    const reason = KUMIMOJI_CHECK_REASONS[code].replace(/\{(\w+)\}/g, (_gap, name) => String(values?.[name]));
+    return values === undefined ? { ok: false, reason, code } : { ok: false, reason, code, values };
+}

package/dist/check.js

@@ -1,6 +1,7 @@
+import { kumimojiRefusal } from "./check-reasons.js";
 import { decodeGrid, lettersOf, sameLetters } from "./grid.js";
 import { judgeWithWords } from "./judge.js";
-import { kumimojiTileCount, kumimojiWildCount, KUMIMOJI_SCORE, TILE_MIX_TOTAL } from "./tiles.constants.js";
+import { KUMIMOJI_SCORE, kumimojiTileCount, kumimojiWildCount, TILE_MIX_TOTAL } from "./tiles.constants.js";
 import { tileWords } from "./tileWords.js";
 /**
  * WHETHER A GRID FINISHES A KUMIMOJI: the one check the server also runs.
@@ -43,35 +44,37 @@ export function checkKumimoji(size, givens, answer, options = {}) {
         inBag = kumimojiTileCount(size, gameLength, language === "english" ? TILE_MIX_TOTAL : setSize, doubleSet);
     }
     catch {
-        return { ok: false, reason: `no Kumimoji with a hand of ${size}` };
+        return kumimojiRefusal("no-hand", { size });
     }
     const bag = [...givens];
     if (typeof givens !== "string" || bag.length !== inBag)
-        return { ok: false, reason: "the givens are not a bag of tiles" };
+        return kumimojiRefusal("givens-not-bag");
     const expectedWilds = kumimojiWildCount(size, level, inBag);
     if (bag.filter(words.isWild).length !== expectedWilds)
-        return { ok: false, reason: "the bag has the wrong number of wild tiles" };
+        return kumimojiRefusal("wild-count-wrong");
     for (const [tile, count] of lettersOf(bag.filter((each) => !words.isWild(each)))) {
         const face = words.inventoryKey(tile);
         const code = face === null ? null : words.codeOf(face);
         if (code === null || count > (words.mix.get(code) ?? 0) * multiplier)
-            return { ok: false, reason: "the bag exceeds the tile set" };
+            return kumimojiRefusal("bag-exceeds-set");
     }
     const tiles = decodeGrid(answer);
     if (tiles === null)
-        return { ok: false, reason: "the answer is not a grid" };
+        return kumimojiRefusal("answer-not-grid");
     const bagIdentities = bag.map(words.familyKey);
     const tileIdentities = [...tiles.values()].map(words.familyKey);
-    if (bagIdentities.some((tile) => tile === null) || tileIdentities.some((tile) => tile === null) || !sameLetters(lettersOf(tileIdentities), lettersOf(bagIdentities))) {
-        return { ok: false, reason: "the grid does not use exactly the tiles of the bag" };
+    if (bagIdentities.some((tile) => tile === null) ||
+        tileIdentities.some((tile) => tile === null) ||
+        !sameLetters(lettersOf(tileIdentities), lettersOf(bagIdentities))) {
+        return kumimojiRefusal("grid-not-the-bag");
     }
     const verdict = judgeWithWords(tiles, words, { diagonals: options.diagonals === true });
     if (verdict.apart.size > 0)
-        return { ok: false, reason: "the tiles are not all joined" };
+        return kumimojiRefusal("tiles-apart");
     if (verdict.notWords.length > 0)
-        return { ok: false, reason: `${verdict.notWords[0]} is not in the word list` };
+        return kumimojiRefusal("not-a-word", { word: verdict.notWords[0] });
     if (!verdict.sound)
-        return { ok: false, reason: "the grid is not finished" };
+        return kumimojiRefusal("grid-not-finished");
     return { ok: true };
 }
 /** A finished game's leaderboard points (`KUMIMOJI_SCORE`): ten a tile, and up to as much again for speed.

package/dist/computerPlay.js

@@ -76,7 +76,7 @@ function lacking(word, hand, most) {
 /** How many tiles already down one word may run through: two lets it bridge a gap, as players do. */
 const CROSSED_MOST = 2;
 /** How many placements are tried in one search at most, so a turn's thinking stays a fraction of a second on a phone. */
-const FITS_MOST = 20000;
+const FITS_MOST = 20_000;
 /** A laying's worth: tiles used first, rare letters next, wilds spent last. */
 function worth(fresh, wilds, words) {
     let rare = 0;
@@ -118,7 +118,8 @@ function layings(play, words, rules) {
     }
     const bounds = boundsOf(play.tiles);
     const fits = (first, last) => bounds === null ||
-        (Math.max(bounds.bottom, last.row) - Math.min(bounds.top, first.row) < KUMIMOJI_GRID_MOST && Math.max(bounds.right, last.col) - Math.min(bounds.left, first.col) < KUMIMOJI_GRID_MOST);
+        (Math.max(bounds.bottom, last.row) - Math.min(bounds.top, first.row) < KUMIMOJI_GRID_MOST &&
+            Math.max(bounds.right, last.col) - Math.min(bounds.left, first.col) < KUMIMOJI_GRID_MOST);
     const found = [];
     let tried = 0;
     let mostFresh = 0;
@@ -150,9 +151,15 @@ function layings(play, words, rules) {
                         if (fit === null)
                             continue;
                         const step = across ? { row: 0, col: 1 } : { row: 1, col: 0 };
-                        if (!fits(fit.first, { row: fit.first.row + (length - 1) * step.row, col: fit.first.col + (length - 1) * step.col }))
+                        if (!fits(fit.first, {
+                            row: fit.first.row + (length - 1) * step.row,
+                            col: fit.first.col + (length - 1) * step.col,
+                        }))
                             continue;
-                        const fresh = fit.fresh.map((square) => ({ square: squareAt(square.row, square.col), letter: word[(square.row - fit.first.row) + (square.col - fit.first.col)] }));
+                        const fresh = fit.fresh.map((square) => ({
+                            square: squareAt(square.row, square.col),
+                            letter: word[square.row - fit.first.row + (square.col - fit.first.col)],
+                        }));
                         const wilds = wildsNeeded(fresh, hand);
                         if (wilds !== null)
                             keep({ word, fresh, wilds, score: worth(fresh, wilds, words) });

package/dist/computerTurn.js

@@ -1,6 +1,6 @@
 import { bestLaying, judgeTiles, tradeChoice } from "./computerPlay.js";
 import { drawAll, isComputer, mayDrawAll, mayTradeThisTurn, seatPlay, withSeatPlay } from "./party.js";
-import { doneRefused, endTurn, goesOut, handCanSpell, isLastTurn, laidThisTurn, mayResign, resign } from "./partyTurns.js";
+import { doneRefused, endTurn, goesOut, handCanSpell, isLastTurn, laidThisTurn, mayResign, resign, } from "./partyTurns.js";
 import { liftAll, mayTrade, trade } from "./play.js";
 /**
  * A COMPUTER'S TURN in a pass-and-play game (John, 2026-09-28: "Also you can
@@ -100,7 +100,10 @@ export function planComputerTurn(game, words) {
             break;
     }
     const hand = now.players[now.turn].hand;
-    const stuck = hand.length > 0 && !laidThisTurn(now) && !mayTrade(seatPlay(now)) && bestLaying(seatPlay(now), words, rules) === null;
+    const stuck = hand.length > 0 &&
+        !laidThisTurn(now) &&
+        !mayTrade(seatPlay(now)) &&
+        bestLaying(seatPlay(now), words, rules) === null;
     const refused = doneRefused(now, verdict(), handSpells) !== null;
     if ((refused || (stuck && !isLastTurn(now))) && mayResign(now)) {
         take(resign(now), { kind: "resigned" });

package/dist/daily.js

@@ -38,5 +38,5 @@ export function kumimojiDay(at) {
  */
 export function kumimojiDailySeed(at) {
     const [year, month, day] = kumimojiDay(at).split("-").map(Number);
-    return year * 10000 + month * 100 + day;
+    return year * 10_000 + month * 100 + day;
 }

package/dist/element.d.ts

@@ -1,5 +1,5 @@
-import { type KumimojiTableHandle, type KumimojiTableOptions } from "./ui/mount.ts";
 import type { KumimojiSaved } from "./export.ts";
+import { type KumimojiTableHandle, type KumimojiTableOptions } from "./ui/mount.ts";
 declare const ElementBase: typeof HTMLElement;
 /**
  * THE `<kumimoji-table>` ELEMENT: a game of Kumimoji alone in a tag, with no
@@ -97,6 +97,9 @@ export declare class KumimojiTable extends ElementBase {
     /** The `controls` attribute, reflected. */
     get controls(): string | null;
     set controls(value: string | number | boolean | null | undefined);
+    /** The `cloth` attribute, reflected: green, blue, red, black or wood. */
+    get cloth(): string | null;
+    set cloth(value: string | number | boolean | null | undefined);
     /** The `theme` attribute, reflected. */
     get theme(): string | null;
     set theme(value: string | number | boolean | null | undefined);