リファレンス

数字パズルのエンジン

import { … } from "@johnmorrisdotca/kazu";

最小化と gzip 圧縮をしたサイズは 64.8 kB（読み込むものをすべて含み、esbuild で計測）

リファレンスの説明と例は英語です。見出しと目次は日本語です。

Kazu 数: the Numbers family of grid puzzles. Sudoku, Jigsaw Sudoku, Diagonal Sudoku, Killer Sudoku (Sum Cages), Futoshiki (More or Less) and Skyscrapers (Towers): a seeded generator whose every puzzle has exactly one answer, at three levels; a solver that counts answers; a check that reads a finished grid in O(cells); a hint that says which cell to fill next and why; puzzles and runs as short codes; and a game in play as pure functions. The drawing is @johnmorrisdotca/kazu/draw, playing in a page is @johnmorrisdotca/kazu/play, and the tag is @johnmorrisdotca/kazu/element/define.

エクスポート

名前	種類	概要
`AKARI_DENSER_ATTEMPTS`	定数	The native Akari generation-attempt limit for each denser fallback.
`AKARI_DENSER_CROWDS`	定数	When a level finds no board in `AKARI_MOST_ATTEMPTS` plain attempts (a large board of an easy level, mostly: one attempt in a hundred succeeds on a 14×14), the generator tries again with more black squares, each of these multiples of the usual share in turn, `AKARI_DENSER_ATTEMPTS` attempts at each.
`AKARI_LEVELS`	定数	How hard a puzzle is made, by what a person must do to solve it; see `rateAkari`.
`AKARI_MOST_ATTEMPTS`	定数	The native Akari generation-attempt limit.
`AKARI_MOST_NODES`	定数	The native Akari search-node budget.
`AKARI_MOST_SIDE`	定数	The maximum supported Akari board dimension.
`AKARI_PLAY_STYLE`	定数	Scoped native Akari board and player CSS.
`AKARI_SIZES`	定数	The sides the demo and the site offer for a square board; any side from 2 to `AKARI_MOST_SIDE` can be made.
`AKARI_STRINGS`	定数	Native English and Japanese labels and announcements for Akari.
`AkariBoard`	型	A board is row-major.
`AkariCheck`	型	The Akari completion result and cells that violate its native rules.
`AkariDrawOptions`	型	Current Akari marks or entries, selection, errors and native SVG appearance choices.
`akariFinished`	関数	A game is finished only when its bulbs satisfy every rule and light every white square.
`AkariGame`	型	The immutable Akari board, current entries or marks, undo history and assistance state.
`AkariLanguage`	型	The native English or Japanese display language for Akari.
`AkariLevel`	型	A native difficulty tier for generated Akari puzzles.
`AkariMaterial`	型	A supported material of the native Akari board.
`AkariMount`	型	The mounted Akari game and progress, native controls and cleanup handle.
`AkariMountOptions`	型	The initial Akari board, native progress, appearance and host event callbacks.
`akariNeighbours`	関数	Returns the orthogonally adjacent cells to a board position.
`AkariPieces`	型	A supported native Akari mark or piece appearance.
`AkariProgress`	型	The Akari constraint status of a partial board.
`AkariPuzzle`	型	A seeded Akari board with its verified solution and native difficulty tier.
`AkariRating`	型	How hard a board is, measured by solving it.
`AkariSolve`	型	A bounded Akari solve result: answer count, first solution, node work and whether the search completed.
`akariVisible`	関数	White squares visible from a cell, including itself, stopping at black squares and edges.
`answerOf`	関数	The whole grid as a cells code: what `checkKazu` takes as an answer.
`boxedLayout`	関数	Rows, columns and boxes; with `diagonal`, the two long diagonals as well.
`Boxes`	型	Where the boxes are on a Sudoku grid: how many rows and columns of cells each box holds.
`boxOf`	関数	The box a cell is in, numbered row-major from 0.
`Cage`	型	A cage: the cells in it and the sum of the numbers inside.
`CAGE_LETTERS`	定数	The letters that name a cage in a code: up to sixty-two cages.
`cageOutline`	関数	THE DASHED OUTLINE OF EVERY CAGE, as line segments in cell units: each cage drawn a little inside its own edge, the way a printed Killer Sudoku draws it, so a cage reads as a shape within the box rules rather than as one of them.
`canReach`	関数	Whether the remaining distinct digits can reach the target sum in the given slots.
`checkAkari`	関数	Checks a complete placement from the public rules, without consulting a stored answer.
`checkCrossSums`	関数	Checks exact run sums and distinct digits independently of a stored answer.
`checkHeyawake`	関数	Validate a Heyawake answer against the printed clues and complete native rules.
`checkHitori`	関数	Checks unshaded row and column duplicates, adjacent shades, and white connectivity.
`checkJuosan`	関数	Checks public rules directly, independently of the solver and stored answer.
`checkKazu`	関数	Whether an answer solves a puzzle: O(cells), no search, nothing remembered between calls.
`checkLoop`	関数	Checks all numbered cells, degree-two vertices, and one connected closed loop.
`checkMasyu`	関数	Validate a Masyu answer against the printed clues and complete native rules.
`checkNurikabe`	関数	Checks island areas and separation, the connected sea, and the ban on 2×2 sea blocks.
`checkRegions`	関数	Checks region connectivity and area without consulting a generated answer.
`checkRipple`	関数	Checks room permutations and the at-least-N-cell gap between equal N clues in a line.
`checkRoomSpans`	関数	Add unshaded straight-line room-span violations to the supplied error set.
`checkShikaku`	関数	A finished partition is checked against the rules, never against a stored answer.
`checkYajilin`	関数	Validate a Yajilin answer against the printed clues and complete native rules.
`clearCell`	関数	Empty a cell of its number and its pencil marks.
`cluesOf`	関数	Every clue a finished square makes true: what each side of it sees.
`conflictsOf`	関数	THE CELLS THAT BREAK A RULE RIGHT NOW, read from the rules alone: no answer is needed, so it works on any puzzle, and it names a mistake the moment it is made rather than when it is checked.
`countKazuSolutions`	関数	How many answers a puzzle has, up to `limit` (two by default, so "many" costs no more than "two"): 1 is a puzzle, 0 is a grid that cannot be finished, 2 is a guessing game.
`CROSS_SUMS_GENERATION_ATTEMPTS`	定数	The native CrossSums generation-attempt limit.
`CROSS_SUMS_GENERATION_NODES`	定数	The native CrossSums search-node budget.
`CROSS_SUMS_LEAST_GENERATED_SIDE`	定数	The minimum supported CrossSums board dimension for generation.
`CROSS_SUMS_LEVELS`	定数	How hard a puzzle is made, by what a person must do to solve it; see `rateCrossSums`.
`CROSS_SUMS_MAX_ATTEMPTS`	定数	The native CrossSums generation-attempt limit.
`CROSS_SUMS_MAX_NODES`	定数	The native CrossSums search-node budget.
`CROSS_SUMS_MAX_SIDE`	定数	The maximum supported CrossSums board dimension.
`CROSS_SUMS_MIN_SIDE`	定数	The minimum supported CrossSums board dimension.
`CROSS_SUMS_PLAY_STYLE`	定数	Scoped native CrossSums board and player CSS.
`CROSS_SUMS_SIZES`	定数	The sides on offer, counting the row and column of totals; any side from 5 to `CROSS_SUMS_MAX_SIDE` can be made.
`CROSS_SUMS_STRINGS`	定数	Native English and Japanese labels and announcements for CrossSums.
`CrossSumsBoard`	型	CrossSums dimensions and printed clues in their native row-major representation.
`CrossSumsCell`	型	A white digit cell or a black clue cell with optional across/down totals.
`CrossSumsCheck`	型	The CrossSums completion result and cells that violate its native rules.
`CrossSumsDrawOptions`	型	Current CrossSums marks or entries, selection, errors and native SVG appearance choices.
`CrossSumsGame`	型	The immutable CrossSums board, current entries or marks, undo history and assistance state.
`CrossSumsLanguage`	型	The native English or Japanese display language for CrossSums.
`CrossSumsLevel`	型	A native difficulty tier for generated CrossSums puzzles.
`CrossSumsMaterial`	型	A supported material of the native CrossSums board.
`CrossSumsMount`	型	The mounted CrossSums game and progress, native controls and cleanup handle.
`CrossSumsMountOptions`	型	The initial CrossSums board, native progress, appearance and host event callbacks.
`CrossSumsPieces`	型	A supported native CrossSums mark or piece appearance.
`CrossSumsPuzzle`	型	A seeded CrossSums board with its verified solution and native difficulty tier.
`CrossSumsRating`	型	How hard a board is, measured by solving it.
`CrossSumsRun`	型	One across or down digit run, its clue cell, constituent cells and target sum.
`crossSumsRuns`	関数	Read across and down digit runs with their clue cells and totals.
`CrossSumsSolve`	型	A bounded CrossSums solve result: answer count, first solution, node work and whether the search completed.
`decodeAkari`	関数	Decodes a bounded save after validating the board and each placement.
`decodeCells`	関数	`".3.1"` at a side of 2 → `[0, 3, 0, 1]`, or null for a string that is not a grid of that size: the wrong length, a value past the side, a stray character.
`decodeCrossSums`	関数	Read a native saved CrossSums game, or null for invalid board data or progress.
`decodeHeyawake`	関数	Read a native saved Heyawake game, or null for invalid board data or progress.
`decodeHitori`	関数	Read a native saved Hitori game, or null for invalid board data or progress.
`decodeJigsaw`	関数	The cells and regions a Jigsaw's givens say, or null for a string that is not a Jigsaw of this side.
`decodeJuosan`	関数	Reads a bounded public save; malformed or incompatible data returns null.
`decodeKiller`	関数	The cells and cages a code says, or null for one that is not a whole, well-formed puzzle: every cell named to a cage, every cage used, and a sum for each.
`decodeLoop`	関数	Read a native saved Loop game, or null for invalid board data or progress.
`decodeMasyu`	関数	Read a native saved Masyu game, or null for invalid board data or progress.
`decodeMoreOrLess`	関数	Decode native Futoshiki numbers and less-than relations, or null for an invalid code.
`decodeNotes`	関数	The pencil marks a code says (each cell a bit mask, bit `v` for the number `v`), or null for a code that is not one for a grid of this side.
`decodeNurikabe`	関数	Read a native saved Nurikabe game, or null for invalid board data or progress.
`decodeRegions`	関数	Regions row-major, one letter each, or null for a string that is not that.
`decodeRegionsGame`	関数	Read a native saved Regions game, or null for invalid board data or progress.
`decodeRipple`	関数	Read a native saved Ripple game, or null for invalid board data or progress.
`decodeRun`	関数	The entries a run's code says, or null for a code that is not a run of this side.
`decodeShikaku`	関数	Read a native saved Shikaku game, or null for invalid board data or progress.
`decodeSteps`	関数	The grids a step log holds, each `cells` characters long, or null for a log that does not read as one.
`decodeTowers`	関数	The cells and clues a code says, or null for a string that is not a Towers puzzle of this size.
`decodeYajilin`	関数	Read a native saved Yajilin game, or null for invalid board data or progress.
`drawAkari`	関数	Draws the public clues and current bulbs as SVG.
`drawCrossSums`	関数	Render the CrossSums board and supplied current state as native SVG text.
`drawHeyawake`	関数	Render the Heyawake board and supplied current state as native SVG text.
`drawJuosan`	関数	Draws a public Juosan board as an SVG string.
`drawLoop`	関数	Draws public clues and selected loop edges as an SVG board.
`drawRegions`	関数	Render the Regions board and supplied current state as native SVG text.
`drawRipple`	関数	Render the Ripple board and supplied current state as native SVG text.
`edgeVertices`	関数	Read the two vertex indices at the ends of a native Loop edge.
`EMPTY_CELL`	定数	A GRID OF NUMBERS AS A STRING: for an address, a POST body, and a kept run.
`encodeAkari`	関数	Encodes only public clues and player placements.
`encodeCells`	関数	`[0, 3, 0, 1]` → `".3.1"`.
`encodeCrossSums`	関数	Encode the CrossSums board and current game as native resumable text.
`encodeHeyawake`	関数	Encode the Heyawake board and current game as native resumable text.
`encodeHitori`	関数	Versioned public clue and mark data; the generated answer is not saved.
`encodeJigsaw`	関数	A Jigsaw's givens: the cells, then the regions, one letter a cell.
`encodeJuosan`	関数	Serializes public clues, placements, and assisted status.
`encodeKiller`	関数	A Sum Cages puzzle's givens: the cells, then which cage each cell is in, then each cage's sum.
`encodeLoop`	関数	Encode the Loop board and current game as native resumable text.
`encodeMasyu`	関数	Encode the Masyu board and current game as native resumable text.
`encodeMoreOrLess`	関数	Encode grid numbers and less-than relations as the native Futoshiki givens code.
`encodeNotes`	関数	Pencil marks as a code: for each cell that has any, its index in base 36 (two characters) and its marks as one number in base 36 (four characters); nothing at all for a grid with none.
`encodeNurikabe`	関数	Encode the Nurikabe board and current game as native resumable text.
`encodeRegions`	関数	The region of every cell as a letter, `a` for the first region and so on: one character a cell.
`encodeRegionsGame`	関数	Encode the Regions board and current game as native resumable text.
`encodeRipple`	関数	Encode the Ripple board and current game as native resumable text.
`encodeRun`	関数	The entries of a run as its code.
`encodeShikaku`	関数	Versioned public puzzle and placement data, with no hidden answer.
`encodeSteps`	関数	THE STEPS OF A PUZZLE, written down so a scrubber has them when the puzzle is picked up again.
`encodeTowers`	関数	Encode grid numbers and four sides of visibility clues as native Skyscrapers givens.
`encodeYajilin`	関数	Encode the Yajilin board and current game as native resumable text.
`enterCrossSums`	関数	Apply the requested native CrossSums entry or mark to a new immutable game; invalid or fixed targets stay unchanged.
`enterNumber`	関数	Write a number into a cell (0 empties it).
`entryRegions`	関数	Group connected cells carrying the same entry into candidate regions.
`finishedCrossSums`	関数	Whether this CrossSums game satisfies its complete native rules.
`freshKazuSeed`	関数	A new seed, from `Math.random` or the stream given: anywhere in the range.
`gameConflicts`	関数	The cells that break a rule now (`conflictsOf`).
`generateAkari`	関数	Makes a seeded board and proves it has one answer.
`generateCrossSums`	関数	Makes a seeded board of `size` squares a side (counting the row and column of totals) and proves it has one answer.
`generateDiagonal`	関数	A Diagonal Sudoku (Sudoku X): Sudoku with the two long diagonals as groups too.
`generateHeyawake`	関数	Generate a seeded Heyawake puzzle with a verified unique answer; unsupported inputs or exhausted attempts throw.
`generateHitori`	関数	Makes a seeded puzzle and proves its answer is the only one.
`generateJigsaw`	関数	A Jigsaw Sudoku of this side, level and seed: 5, 6, 7 or 9.
`generateJuosan`	関数	Makes an original small training puzzle and returns it only after uniqueness is proved.
`generateKazu`	関数	A puzzle of any of the six, from a seed: the one door.
`generateLoop`	関数	Makes a seeded puzzle and proves it has one answer.
`generateMasyu`	関数	Seeded original loop layouts; every output is accepted only after a completed uniqueness proof.
`generateMoreOrLess`	関数	A Futoshiki (More or Less) of this side, level and seed: 4, 5, 6 or 7.
`generateNumberPlace`	関数	A Sudoku (Number Place) of this side, level and seed: 4, 6, 9, 16 or 25.
`generateNurikabe`	関数	Seeded symmetries of original 5×5 layouts are returned only after the solver proves uniqueness.
`generateRegions`	関数	Makes a seeded puzzle and proves its answer is the only one.
`generateRipple`	関数	Builds a seeded block-room family and accepts it only after a bounded uniqueness proof.
`generateShikaku`	関数	Seeded rectangles packed into the board, one number each, with an independently counted, unique answer.
`generateShikakuChallenge`	関数	Generate a seeded Shikaku puzzle with a verified unique answer; unsupported inputs or exhausted attempts throw.
`generateSumCages`	関数	A Killer Sudoku (Sum Cages) of this side, level and seed: 6 or 9.
`generateTowers`	関数	A Skyscrapers (Towers) puzzle of this side, level and seed: 4, 5, 6 or 7.
`generateYajilin`	関数	Seeded original 5×5 families, accepted only after a completed uniqueness proof.
`HEYAWAKE_GENERATOR_MOST_CELLS`	定数	The maximum number of cells accepted by the Heyawake generator.
`HEYAWAKE_LEVELS`	定数	The native Heyawake generation difficulty tiers.
`HEYAWAKE_MOST_ATTEMPTS`	定数	The native Heyawake generation-attempt limit.
`HEYAWAKE_MOST_NODES`	定数	The native Heyawake search-node budget.
`HEYAWAKE_MOST_SIDE`	定数	The maximum supported Heyawake board dimension.
`HEYAWAKE_PLAY_STYLE`	定数	Scoped native Heyawake board and player CSS.
`HeyawakeAppearance`	型	Language, material and marks for a native Heyawake board.
`HeyawakeBoard`	型	Heyawake dimensions and printed clues in their native row-major representation.
`heyawakeCells`	関数	Read room cells, or null for a room outside this board.
`HeyawakeCheck`	型	The Heyawake completion result and cells that violate its native rules.
`HeyawakeDrawOptions`	型	Current Heyawake marks or entries, selection, errors and native SVG appearance choices.
`heyawakeFinished`	関数	Whether this Heyawake game satisfies its complete native rules.
`HeyawakeGame`	型	The immutable Heyawake board, current entries or marks, undo history and assistance state.
`HeyawakeLevel`	型	A native difficulty tier for generated Heyawake puzzles.
`HeyawakeMount`	型	The mounted Heyawake game and progress, native controls and cleanup handle.
`HeyawakeMountOptions`	型	The initial Heyawake board, native progress, appearance and host event callbacks.
`heyawakeNeighbours`	関数	Read orthogonally adjacent Heyawake cells.
`HeyawakePuzzle`	型	A seeded Heyawake board with its verified solution and native difficulty tier.
`HeyawakeRoom`	型	A rectangular room and its optional required black-cell count.
`HeyawakeSolve`	型	A bounded Heyawake solve result: answer count, first solution, node work and whether the search completed.
`heyawakeWords`	関数	Read the native English or Japanese Heyawake labels.
`hintAkari`	関数	Returns a missing bulb, or an extra bulb to remove, only after uniqueness is proved.
`hintCrossSums`	関数	Find a native CrossSums hint, or null when no actionable hint is available.
`hintHeyawake`	関数	Find a native Heyawake hint, or null when no actionable hint is available.
`hintHitori`	関数	Gives one next shade in the unique minimal solution, if uniqueness was proved.
`hintJuosan`	関数	Returns one next mark only when the public clues prove a unique answer.
`hintKazu`	関数	The next cell a person could fill in, and why (see `KazuHint`).
`hintLoop`	関数	Find a native Loop hint, or null when no actionable hint is available.
`hintMasyu`	関数	Find a native Masyu hint, or null when no actionable hint is available.
`hintNurikabe`	関数	Find a native Nurikabe hint, or null when no actionable hint is available.
`hintRegions`	関数	Find a native Regions hint, or null when no actionable hint is available.
`hintRipple`	関数	Offers a cell only when the current public entries leave one proved completion.
`hintShikaku`	関数	A rectangle is offered only when the remaining partition has one proved answer.
`hintYajilin`	関数	Find a native Yajilin hint, or null when no actionable hint is available.
`HITORI_LEAST_SIDE`	定数	The minimum supported Hitori board dimension.
`HITORI_LEVELS`	定数	How hard a puzzle is made, by what a person must do to solve it; see `rateHitori`.
`HITORI_MAX_NODES`	定数	The native Hitori search-node budget.
`HITORI_MOST_ATTEMPTS`	定数	The native Hitori generation-attempt limit.
`HITORI_MOST_SIDE`	定数	The maximum supported Hitori board dimension.
`HITORI_SIZES`	定数	The sides on offer; any side from 4 to `HITORI_MOST_SIDE` is a board `isHitoriBoard` takes.
`HitoriBoard`	型	Hitori dimensions and printed clues in their native row-major representation.
`HitoriGame`	型	The immutable Hitori board, current entries or marks, undo history and assistance state.
`HitoriLevel`	型	A native difficulty tier for generated Hitori puzzles.
`hitoriNeighbors`	関数	Read orthogonally adjacent cells on a square Hitori board.
`HitoriPuzzle`	型	A seeded Hitori board with its verified solution and native difficulty tier.
`HitoriRating`	型	How hard a board is, measured by solving it.
`HitoriSolve`	型	A bounded Hitori solve result: answer count, first solution, node work and whether the search completed.
`isAkariBoard`	関数	Validates dimensions and the three public square kinds.
`isCrossSumsBoard`	関数	Whether the value has valid native CrossSums dimensions, clues and data.
`isHeyawakeBoard`	関数	Whether the value has valid native Heyawake dimensions, clues and data.
`isHitoriBoard`	関数	Whether the value has valid native Hitori dimensions, clues and data.
`isJuosanBoard`	関数	Whether territories partition a bounded board and each territory is connected.
`isKazuGivens`	関数	Whether a puzzle's givens are a well-formed puzzle of that kind and side at all (a Jigsaw's regions sound, every code readable).
`isKazuKind`	関数	Whether a value is one of the six keys.
`isKazuLevel`	関数	Whether a value is one of the three levels.
`isKazuSeed`	関数	Whether a value is a seed this package takes: a whole number from 1 to `KAZU_SEED_MOST`.
`isKazuSize`	関数	Whether this puzzle can be made at this side.
`isLoopBoard`	関数	Whether the value has valid native Loop dimensions, clues and data.
`isMasyuBoard`	関数	Whether the value has valid native Masyu dimensions, clues and data.
`isNurikabeBoard`	関数	Whether the value has valid native Nurikabe dimensions, clues and data.
`isPrinted`	関数	Whether a cell was printed with its number: it never changes.
`isRegionsBoard`	関数	Whether the value has valid native Regions dimensions, clues and data.
`isRippleBoard`	関数	Whether the value has valid native Ripple dimensions, clues and data.
`isShikakuBoard`	関数	Whether dimensions and area clues describe a possible partition.
`isSolved`	関数	Whether the grid is full and right, by the rules alone (`checkKazu`): every puzzle has exactly one answer, so a grid that keeps every rule IS that answer.
`isYajilinBoard`	関数	Whether the value has valid native Yajilin dimensions, clues and data.
`JUOSAN_LEVELS`	定数	The native Juosan generation difficulty tiers.
`JUOSAN_MOST_ATTEMPTS`	定数	The native Juosan generation-attempt limit.
`JUOSAN_MOST_NODES`	定数	The native Juosan search-node budget.
`JUOSAN_MOST_SIDE`	定数	The maximum supported Juosan board dimension.
`JUOSAN_PLAY_STYLE`	定数	Scoped native Juosan board and player CSS.
`JUOSAN_STRINGS`	定数	Native English and Japanese labels and announcements for Juosan.
`JuosanBoard`	型	Juosan dimensions and printed clues in their native row-major representation.
`JuosanCheck`	型	The Juosan completion result and cells that violate its native rules.
`JuosanDrawOptions`	型	Current Juosan marks or entries, selection, errors and native SVG appearance choices.
`juosanFinished`	関数	Whether every cell is filled and the independent checker accepts the board.
`JuosanGame`	型	The immutable Juosan board, current entries or marks, undo history and assistance state.
`JuosanLanguage`	型	The native English or Japanese display language for Juosan.
`JuosanLevel`	型	A native difficulty tier for generated Juosan puzzles.
`JuosanMark`	型	A blank, horizontal or vertical mark in a Juosan cell.
`JuosanMaterial`	型	A supported material of the native Juosan board.
`JuosanMount`	型	The mounted Juosan game and progress, native controls and cleanup handle.
`JuosanMountOptions`	型	The initial Juosan board, native progress, appearance and host event callbacks.
`JuosanPieces`	型	A supported native Juosan mark or piece appearance.
`JuosanPuzzle`	型	A seeded Juosan board with its verified solution and native difficulty tier.
`JuosanSolve`	型	A bounded Juosan solve result: answer count, first solution, node work and whether the search completed.
`JuosanTerritory`	型	A territory is a list of zero-based cell indexes and an absolute orientation difference.
`juosanTerritoryAt`	関数	Returns the index of the territory containing a cell, or -1 when absent.
`KAZU_BOXES`	定数	A 9×9 has 3×3 boxes and a 4×4 has 2×2; a 6×6 has boxes two rows tall and three columns wide, which is the one people get wrong and the reason this is a table rather than a square root.
`KAZU_KIND_OF_SITE_KIND`	定数	The names itsutsu.com gave the six in its code, to the keys here: what a site's stored kind becomes.
`KAZU_KINDS`	定数	THE SIX PUZZLES, and what each offers: the keys, the sizes and the levels.
`KAZU_LEVELS`	定数	How hard a puzzle is made: what the solver needed.
`KAZU_SEED_MOST`	定数	The most a seed can be: a whole number from 1 to 2³¹ − 1, so it travels in an address as a plain integer.
`KAZU_SPECS`	定数	Supported sizes, native default size and givens-code limits for each number-grid kind.
`KAZU_STEPS_KEPT`	定数	How many grids a step log keeps: the newest, so a long puzzle's log has a ceiling.
`KazuCheck`	型	The verdict on a submitted answer: `{ ok: true }`, or `{ ok: false, reason }` in the words the site has always used.
`kazuClockText`	関数	A time taken, as a clock shows it: `m:ss`, and `h:mm:ss` past an hour.
`KazuGame`	型	A PUZZLE IN PLAY, as pure functions: what has been written, the pencil marks, and how to take a step back.
`KazuGameOptions`	型	Optional entries and pencil-note masks to restore when creating a native number-grid game.
`KazuGivens`	型	WHAT A PUZZLE WAS PRINTED WITH, read from its givens code: the printed cells, and for a Jigsaw its regions, for Sum Cages its cages, for More or Less its marks, for Towers its clues.
`kazuGuessDepth`	関数	How many guesses, each followed by everything reasoning then finds, a person needs to finish the puzzle: 0 when reasoning alone finishes it (easy), 1 when one guess does (medium), more when more (hard); Infinity when there is no answer.
`kazuHash`	関数	A short fingerprint of a puzzle's givens (FNV-1a, eight hex characters): the same puzzle, however it was kept, has the same one.
`KazuHint`	型	A HINT: the next cell a person could fill in by looking, and why.
`KazuKind`	型	One of the six native number-grid puzzle kinds.
`KazuLevel`	型	One of the native easy, medium or hard generation tiers.
`kazuProgress`	関数	How far along it is: cells with a number (printed or written) out of all of them.
`KazuPuzzle`	型	One puzzle, made from a seed or read back from its codes.
`KazuSpec`	型	What one puzzle offers.
`layoutOfGivens`	関数	The groups that must each hold every number once, for the four kinds made of groups; null for More or Less and Towers, which only have rows and columns.
`lineFrom`	関数	The cells a clue looks along, nearest first: the clue at `at` on the top looks down column `at`, on the bottom up it, on the left along row `at` to the right, on the right along it to the left.
`LOOP_LEVELS`	定数	How hard a puzzle is made, by what a person must do to solve it; see `rateLoop`.
`LOOP_MOST_ATTEMPTS`	定数	The native Loop generation-attempt limit.
`LOOP_MOST_NODES`	定数	The native Loop search-node budget.
`LOOP_MOST_SIDE`	定数	The maximum supported Loop board dimension.
`LOOP_SIZES`	定数	The sides on offer for a square board; any side from 2 to `LOOP_MOST_SIDE` can be made.
`LoopBoard`	型	Loop dimensions and printed clues in their native row-major representation.
`loopCellEdges`	関数	Read the four edges around a cell, or null for a cell outside the board.
`LoopCheck`	型	The Loop completion result and cells that violate its native rules.
`LoopDrawOptions`	型	Current Loop marks or entries, selection, errors and native SVG appearance choices.
`loopEdgeCount`	関数	An edge index is horizontal row-major first, then vertical row-major.
`loopFinished`	関数	Whether this Loop game satisfies its complete native rules.
`LoopGame`	型	The immutable Loop board, current entries or marks, undo history and assistance state.
`loopHorizontalCount`	関数	Count horizontal edges in the Loop board’s native edge numbering.
`LoopLanguage`	型	The native English or Japanese display language for Loop.
`LoopLevel`	型	A native difficulty tier for generated Loop puzzles.
`LoopMaterial`	型	A supported material of the native Loop board.
`LoopMount`	型	The mounted Loop game and progress, native controls and cleanup handle.
`LoopMountOptions`	型	The initial Loop board, native progress, appearance and host event callbacks.
`LoopProgress`	型	The Loop constraint status of a partial board.
`LoopPuzzle`	型	A seeded Loop board with its verified solution and native difficulty tier.
`LoopRating`	型	How hard a board is, measured by solving it.
`LoopSolve`	型	A bounded Loop solve result: answer count, first solution, node work and whether the search completed.
`loopVertexEdges`	関数	Read edges meeting a native Loop vertex.
`Mark`	型	A mark: the cell at `less` holds a smaller number than the cell at `more`.
`markNurikabeSea`	関数	Apply the requested native Nurikabe entry or mark to a new immutable game; invalid or fixed targets stay unchanged.
`MASYU_NODE_BUDGET`	定数	The native Masyu search-node budget.
`MASYU_SIZES`	定数	The supported Masyu board sizes.
`MasyuBoard`	型	Masyu dimensions and printed clues in their native row-major representation.
`masyuCellCount`	関数	Count cells in a Masyu board.
`MasyuCheck`	型	The Masyu completion result and cells that violate its native rules.
`MasyuDrawOptions`	型	Current Masyu marks or entries, selection, errors and native SVG appearance choices.
`masyuEdgeCount`	関数	Count native Masyu edges.
`masyuFinished`	関数	Whether this Masyu game satisfies its complete native rules.
`MasyuGame`	型	The immutable Masyu board, current entries or marks, undo history and assistance state.
`MasyuMount`	型	The mounted Masyu game and progress, native controls and cleanup handle.
`MasyuMountOptions`	型	The initial Masyu board, native progress, appearance and host event callbacks.
`masyuNeighbors`	関数	Read adjacent Masyu cells with the joining edge and direction.
`MasyuPuzzle`	型	A seeded Masyu board with its verified solution.
`MasyuSolve`	型	A bounded Masyu solve result: answer count, first solution, node work and whether the search completed.
`mountAkari`	関数	Mounts the player in a host element; call destroy when the host is removed.
`mountCrossSums`	関数	Mount the native CrossSums player in a host element and return its cleanup and control handle.
`mountHeyawake`	関数	Mount the native Heyawake player in a host element and return its cleanup and control handle.
`mountJuosan`	関数	Mounts a touch, mouse, and keyboard player into an existing page element.
`mountLoop`	関数	Mounts an accessible dot-and-edge loop player in the given host element.
`mountRipple`	関数	Mount the native Ripple player in a host element and return its cleanup and control handle.
`neighbours`	関数	The cells sharing an edge with `index`.
`newAkari`	関数	Starts a game with only its public board data.
`newCrossSums`	関数	Create the initial immutable CrossSums game from a valid board.
`newHeyawake`	関数	Create the initial immutable Heyawake game from a valid board.
`newHitori`	関数	Create the initial immutable Hitori game from a valid board.
`newJuosan`	関数	Starts a game with a copy of its public board and no generated answer.
`newKazuGame`	関数	A game of a puzzle, or null for givens that are not a puzzle of that kind and side.
`newLoop`	関数	Create the initial immutable Loop game from a valid board.
`newMasyu`	関数	Create the initial immutable Masyu game from a valid board.
`newNurikabe`	関数	Create the initial immutable Nurikabe game from a valid board.
`newRegions`	関数	Create the initial immutable Regions game from a valid board.
`newRipple`	関数	Create the initial immutable Ripple game from a valid board.
`newShikaku`	関数	Begin with a copy of just the public clues; a generated answer is never kept in play.
`newYajilin`	関数	Create the initial immutable Yajilin game from a valid board.
`NO_MARK`	定数	The native code character for an absent Futoshiki relation.
`noClues`	関数	Create empty visibility clues on all four sides of a square grid.
`notesOf`	関数	Every value of a pencil-mark mask, smallest first.
`numberCounts`	関数	The numbers 1 up to the side, each with how many of it are on the grid: a pad greys a number that is all placed.
`NURIKABE_MAX_NODES`	定数	The native Nurikabe search-node budget.
`NURIKABE_SIZES`	定数	The supported Nurikabe board sizes.
`NurikabeBoard`	型	Nurikabe dimensions and printed clues in their native row-major representation.
`NurikabeGame`	型	The immutable Nurikabe board, current entries or marks, undo history and assistance state.
`nurikabeNeighbors`	関数	Read orthogonally adjacent cells on a square Nurikabe board.
`NurikabePuzzle`	型	A seeded Nurikabe board with its verified solution.
`NurikabeSolve`	型	A bounded Nurikabe solve result: answer count, first solution, node work and whether the search completed.
`placeShikaku`	関数	Place a rectangle, replacing any it touches.
`progressAkari`	関数	Reports immediate contradictions while allowing required clues to remain unsatisfied during play.
`progressCrossSums`	関数	Allows unfinished runs while flagging duplicate digits and impossible remaining totals.
`progressLoop`	関数	Reports overfilled clues and branched vertices during play without requiring a finished loop.
`progressRipple`	関数	Partial progress check; missing entries are allowed, but impossible room/ripple pairs are flagged.
`Random`	型	A number in [0, 1), like `Math.random`, from a stream a seed fixes.
`rateAkari`	関数	Rates a board by solving it as a person would: with the rules alone (depth 0), then with one supposition at a time (depth 1), and anything beyond that is depth 2.
`rateCrossSums`	関数	Rates a board with one answer by solving it: with the single-run rules, with the digit-that-must-appear rule, then by supposing.
`rateHitori`	関数	Rates a board with one answer by solving it: with the plain rules, with the whites-stay-together rule, then by supposing.
`rateLoop`	関数	Rates a board with one answer by solving it as a person would: with the rules, then by supposing one edge at a time.
`rateRegions`	関数	Rates a board with one answer by solving it as a person would: with the rules, then by supposing one number at a time.
`rateShikaku`	関数	Rates a board with one answer by solving it with the first rule, with the first two, with all three, then by supposing.
`readGivens`	関数	The givens of a puzzle, or null for a code that is not one of that kind and side.
`REGIONS_GENERATOR_MOST_CELLS`	定数	The maximum number of cells accepted by the Regions generator.
`REGIONS_LEAST_GENERATED_SIDE`	定数	The minimum supported Regions board dimension for generation.
`REGIONS_LEVELS`	定数	How hard a puzzle is made, by what a person must do to solve it; see `rateRegions`.
`REGIONS_MOST_ATTEMPTS`	定数	The native Regions generation-attempt limit.
`REGIONS_MOST_NODES`	定数	The native Regions search-node budget.
`REGIONS_MOST_SIDE`	定数	The maximum supported Regions board dimension.
`REGIONS_SIZES`	定数	The sides on offer for a square board; any side from 4 to `REGIONS_MOST_SIDE` can be made.
`regionsAreSound`	関数	Whether `region` divides a size×size grid into `size` regions of `size` cells each, every one of them joined edge to edge.
`RegionsBoard`	型	Regions dimensions and printed clues in their native row-major representation.
`RegionsCheck`	型	The Regions completion result and cells that violate its native rules.
`RegionsDrawOptions`	型	Current Regions marks or entries, selection, errors and native SVG appearance choices.
`regionsFinished`	関数	Whether this Regions game satisfies its complete native rules.
`RegionsGame`	型	The immutable Regions board, current entries or marks, undo history and assistance state.
`RegionsLevel`	型	A native difficulty tier for generated Regions puzzles.
`regionsNeighbours`	関数	Read orthogonally adjacent Regions cells.
`RegionsPuzzle`	型	A seeded Regions board with its verified solution and native difficulty tier.
`RegionsRating`	型	How hard a board is, measured by solving it.
`RegionsSolve`	型	A bounded Regions solve result: answer count, first solution, node work and whether the search completed.
`removeShikaku`	関数	Remove the rectangle containing a cell.
`restartCrossSums`	関数	Return the CrossSums game reset to its initial entries or marks.
`restartHeyawake`	関数	Return the Heyawake game reset to its initial entries or marks.
`restartHitori`	関数	Return the Hitori game reset to its initial entries or marks.
`restartJuosan`	関数	Clears the board while retaining whether the player used a hint.
`restartKazu`	関数	Start again: every entry and pencil mark gone, and nothing to undo.
`restartMasyu`	関数	Return the Masyu game reset to its initial entries or marks.
`restartNurikabe`	関数	Return the Nurikabe game reset to its initial entries or marks.
`restartRegions`	関数	Return the Regions game reset to its initial entries or marks.
`restartYajilin`	関数	Return the Yajilin game reset to its initial entries or marks.
`RIPPLE_MAX_ATTEMPTS`	定数	The native Ripple generation-attempt limit.
`RIPPLE_MAX_NODES`	定数	The native Ripple search-node budget.
`RIPPLE_MAX_SIDE`	定数	The maximum supported Ripple board dimension.
`RIPPLE_MIN_SIDE`	定数	The minimum supported Ripple board dimension.
`RIPPLE_PLAY_STYLE`	定数	Scoped native Ripple board and player CSS.
`RIPPLE_STRINGS`	定数	Native English and Japanese labels and announcements for Ripple.
`RippleBoard`	型	Ripple dimensions and printed clues in their native row-major representation.
`RippleCheck`	型	The Ripple completion result and cells that violate its native rules.
`RippleDrawOptions`	型	Current Ripple marks or entries, selection, errors and native SVG appearance choices.
`rippleFinished`	関数	Whether this Ripple game satisfies its complete native rules.
`RippleGame`	型	The immutable Ripple board, current entries or marks, undo history and assistance state.
`RippleLanguage`	型	The native English or Japanese display language for Ripple.
`RippleMaterial`	型	A supported material of the native Ripple board.
`RippleMount`	型	The mounted Ripple game and progress, native controls and cleanup handle.
`RippleMountOptions`	型	The initial Ripple board, native progress, appearance and host event callbacks.
`RipplePieces`	型	A supported native Ripple mark or piece appearance.
`RipplePuzzle`	型	A seeded Ripple board with its verified solution.
`rippleRoomSizes`	関数	Read the size of each room in a Ripple Effect board.
`RippleSolve`	型	A bounded Ripple solve result: answer count, first solution, node work and whether the search completed.
`roomForCell`	関数	Read the containing room index for each Heyawake cell.
`seededRandom`	関数	A stream of numbers in [0, 1) fixed by a seed.
`Segment`	型	A line segment in cell units: where one part of a cage's dashed outline runs.
`setHeyawakeCell`	関数	Apply the requested native Heyawake entry or mark to a new immutable game; invalid or fixed targets stay unchanged.
`setJuosanMark`	関数	Writes a mark and records the previous state; invalid or unchanged moves are ignored.
`setRegionsCell`	関数	Apply the requested native Regions entry or mark to a new immutable game; invalid or fixed targets stay unchanged.
`setRippleValue`	関数	Apply the requested native Ripple entry or mark to a new immutable game; invalid or fixed targets stay unchanged.
`shadeHitori`	関数	Apply the requested native Hitori entry or mark to a new immutable game; invalid or fixed targets stay unchanged.
`SHIKAKU_CHALLENGE_PACKS`	定数	Three short, named challenge routes using the regular seeded unique-puzzle generator.
`SHIKAKU_LEVELS`	定数	How hard a puzzle is made, by what a person must do to solve it; see `rateShikaku`.
`SHIKAKU_MOST_ATTEMPTS`	定数	The native Shikaku generation-attempt limit.
`SHIKAKU_MOST_NODES`	定数	The native Shikaku search-node budget.
`SHIKAKU_MOST_SIDE`	定数	Bounds keep custom boards and searches finite.
`SHIKAKU_SIZES`	定数	The sides on offer for a square board; any side from 2 to `SHIKAKU_MOST_SIDE` can be made.
`ShikakuBoard`	型	One area clue per rectangle; zero is an unnumbered cell.
`shikakuCandidates`	関数	All legal rectangles for a numbered cell, in a stable order.
`shikakuCells`	関数	Cells of a bounded rectangle, or null for invalid coordinates.
`ShikakuChallenge`	型	The named route, board shape, difficulty and seed of one Shikaku challenge.
`ShikakuChallengePuzzle`	型	A named Shikaku challenge paired with its generated unique puzzle.
`ShikakuCheck`	型	The Shikaku completion result and cells that violate its native rules.
`shikakuFinished`	関数	Whether this Shikaku game satisfies its complete native rules.
`ShikakuGame`	型	The immutable Shikaku board, current entries or marks, undo history and assistance state.
`ShikakuLevel`	型	A native difficulty tier for generated Shikaku puzzles.
`ShikakuPackKey`	型	One of the square, wide or tall native Shikaku challenge routes.
`ShikakuPuzzle`	型	A seeded Shikaku board with its verified solution and native difficulty tier.
`ShikakuRating`	型	How hard a board is, measured by solving it.
`ShikakuRectangle`	型	A rectangle uses zero-based column and row coordinates.
`ShikakuSolve`	型	A bounded Shikaku solve result: answer count, first solution, node work and whether the search completed.
`shuffled`	関数	A copy of the list in a random order (Fisher–Yates, from the end); the list given is left alone.
`solveAkari`	関数	Bounded constraint search over the rules in `akariLogic.ts`; a stopped proof is always marked incomplete.
`solveCrossSums`	関数	Bounded exact counter over across and down runs; an interrupted search never proves uniqueness.
`solveHeyawake`	関数	Search for Heyawake answers up to the solution and node limits; completion distinguishes a proved result from exhausted work.
`solveHitori`	関数	Counts distinct minimal shade patterns: an answer shades only squares that settle a duplicate, so extra shades are never a second answer.
`solveJuosan`	関数	Counts labeled solutions up to a limit; `complete` distinguishes exhaustion from cutoff.
`solveKazu`	関数	The one answer a puzzle's givens allow, as a cells code, or null when they allow none, more than one, or the search ran past `budget` steps (Sudoku, Jigsaw, Diagonal and Sum Cages).
`solveLoop`	関数	Counts loop solutions with the pruning in `loopLogic.ts` under explicit work bounds.
`solveMasyu`	関数	Counts distinct single loops with local pearl rules; budget stops never claim a proof.
`solveNurikabe`	関数	Counts valid island placements and checks the remaining cells as the sea under a finite budget.
`solveRegions`	関数	Counts completed partitions.
`solveRipple`	関数	Counts rule-valid fillings within an explicit node budget.
`solveShikaku`	関数	Exact cover over squares.
`solveYajilin`	関数	Counts public shade patterns whose remaining cells form the single required loop.
`stepEntry`	関数	The number a tap on the chosen cell puts in it: one more, and after the largest the cell empties, and then it starts again at 1.
`symbolOf`	関数	How a value is written, in a code and on a cell: 1–9, then A–P.
`toggleAkari`	関数	Toggles a bulb on a white square and keeps one prior turn for undo.
`toggleLoop`	関数	Apply the requested native Loop entry or mark to a new immutable game; invalid or fixed targets stay unchanged.
`toggleMasyuEdge`	関数	Apply the requested native Masyu entry or mark to a new immutable game; invalid or fixed targets stay unchanged.
`toggleNote`	関数	Turn the pencil mark `value` on or off in a cell.
`toggleRippleNote`	関数	Apply the requested native Ripple entry or mark to a new immutable game; invalid or fixed targets stay unchanged.
`toggleYajilinEdge`	関数	Apply the requested native Yajilin entry or mark to a new immutable game; invalid or fixed targets stay unchanged.
`toggleYajilinShade`	関数	Apply the requested native Yajilin entry or mark to a new immutable game; invalid or fixed targets stay unchanged.
`TOWER_SIDES`	定数	Towers (Skyscrapers) as a string: the cells, then the clues around the edge.
`TowerClues`	型	Each side's clues, in reading order along it; 0 where there is none.
`TowerSide`	型	The top, bottom, left or right side of Skyscrapers visibility clues.
`towersSeen`	関数	How many towers show looking along `heights` from its first end: each one taller than every one before it.
`undoAkari`	関数	Restores the last bulb placement.
`undoCrossSums`	関数	Return the CrossSums game with its previous marks or entries restored, or unchanged when there is no undo history.
`undoHeyawake`	関数	Return the Heyawake game with its previous marks or entries restored, or unchanged when there is no undo history.
`undoHitori`	関数	Return the Hitori game with its previous marks or entries restored, or unchanged when there is no undo history.
`undoJuosan`	関数	Restores the preceding mark state, if one exists.
`undoKazu`	関数	Take back the last change.
`undoLoop`	関数	Return the Loop game with its previous marks or entries restored, or unchanged when there is no undo history.
`undoMasyu`	関数	Return the Masyu game with its previous marks or entries restored, or unchanged when there is no undo history.
`undoNurikabe`	関数	Return the Nurikabe game with its previous marks or entries restored, or unchanged when there is no undo history.
`undoRegions`	関数	Return the Regions game with its previous marks or entries restored, or unchanged when there is no undo history.
`undoRipple`	関数	Return the Ripple game with its previous marks or entries restored, or unchanged when there is no undo history.
`undoShikaku`	関数	Return the Shikaku game with its previous marks or entries restored, or unchanged when there is no undo history.
`undoYajilin`	関数	Return the Yajilin game with its previous marks or entries restored, or unchanged when there is no undo history.
`valueOfSymbol`	関数	The value a symbol names, or 0 for one that is not 1–9 or A–P (either case).
`valuesOf`	関数	The whole grid as it stands: the printed numbers, and the player's where nothing is printed.
`VERSION`	定数	The package's version.
`YAJILIN_NODE_BUDGET`	定数	The native Yajilin search-node budget.
`YAJILIN_SIZES`	定数	The supported Yajilin board sizes.
`YajilinBoard`	型	Yajilin dimensions and printed clues in their native row-major representation.
`YajilinCheck`	型	The Yajilin completion result and cells that violate its native rules.
`YajilinClue`	型	An arrow direction and the required number of shaded cells in its ray.
`YajilinDirection`	型	The direction an arrow clue looks along a row or column.
`YajilinDrawOptions`	型	Current Yajilin marks or entries, selection, errors and native SVG appearance choices.
`yajilinEdgeCount`	関数	Count native Yajilin edges.
`YajilinGame`	型	The immutable Yajilin board, current entries or marks, undo history and assistance state.
`YajilinMount`	型	The mounted Yajilin game and progress, native controls and cleanup handle.
`YajilinMountOptions`	型	The initial Yajilin board, native progress, appearance and host event callbacks.
`yajilinNeighbors`	関数	Read adjacent Yajilin cells and the joining edge.
`YajilinPuzzle`	型	A seeded Yajilin board with its verified solution.
`yajilinRay`	関数	Read cells in the arrow’s indicated direction, excluding its own clue cell.
`YajilinSolution`	型	The solved Yajilin shading and loop edges.
`YajilinSolve`	型	A bounded Yajilin solve result: answer count, first solution, node work and whether the search completed.

ソースを見る GitHub で編集@johnmorrisdotca/kazu 2.1.0 のソースから作成しました。

この日本語は、まだ日本語を母語とする方の確認を受けていません。訂正を歓迎します。