SYMBOL INDEX (537 symbols across 47 files)

FILE: src/action/action.ts
  type SingleArgument (line 16) | type SingleArgument = string | number | boolean | GameElement | Player;
  type Argument (line 29) | type Argument = SingleArgument | SingleArgument[];
  type ActionStub (line 35) | type ActionStub = {
  type Group (line 64) | type Group = Record<string,
  type ExpandGroup (line 70) | type ExpandGroup<A extends Record<string, Argument>, R extends Group> = ...
  class Action (line 93) | class Action<A extends Record<string, Argument> = NonNullable<unknown>> {
    method constructor (line 106) | constructor({ prompt, description, condition }: {
    method isPossible (line 116) | isPossible(args: A): boolean {
    method _getPendingMoves (line 127) | _getPendingMoves(args: Record<string, Argument>, debug?: ActionDebug):...
    method _getPendingMovesInner (line 172) | _getPendingMovesInner(args: Record<string, Argument>, debug?: ActionDe...
    method _nextSelection (line 250) | _nextSelection(args: Record<string, Argument>): ResolvedSelection | un...
    method _process (line 267) | _process(player: Player, args: Record<string, Argument>): string | und...
    method _addSelection (line 314) | _addSelection(selection: Selection) {
    method _withDecoratedArgs (line 322) | _withDecoratedArgs(args: A, fn: (args: A) => any) {
    method _getError (line 344) | _getError(selection: ResolvedSelection, args: A) {
    method _getConfirmation (line 348) | _getConfirmation(selection: ResolvedSelection, args: A) {
    method do (line 386) | do(move: (args: A) => any): Action<A> {
    method message (line 425) | message(text: string, args?: Record<string, Argument> | ((a: A) => Rec...
    method messageTo (line 466) | messageTo(player: (Player | number) | (Player | number)[], text: strin...
    method chooseFrom (line 564) | chooseFrom<N extends string, T extends SingleArgument>(
    method enterText (line 614) | enterText<N extends string>(name: N, options?: {
    method chooseNumber (line 689) | chooseNumber<N extends string>(name: N, options: {
    method chooseOnBoard (line 805) | chooseOnBoard<T extends GameElement, N extends string>(name: N, choice...
    method choose (line 853) | choose<N extends string, S extends 'select' | 'number' | 'text' | 'boa...
    method chooseGroup (line 904) | chooseGroup<R extends Group>(
    method confirm (line 948) | confirm(prompt: string | ((args: A) => string)): Action<A> {
    method move (line 976) | move(piece: keyof A | Piece<Game>, into: keyof A | GameElement) {
    method swap (line 1013) | swap(piece1: keyof A | Piece<Game>, piece2: keyof A | Piece<Game>) {
    method reorder (line 1053) | reorder(collection: Piece<Game>[], options?: {
    method placePiece (line 1123) | placePiece<T extends keyof A & string>(piece: T, into: PieceGrid<Game>...

FILE: src/action/selection.ts
  type BoardQuerySingle (line 8) | type BoardQuerySingle<T extends GameElement, A extends Record<string, Ar...
  type BoardQueryMulti (line 9) | type BoardQueryMulti<T extends GameElement, A extends Record<string, Arg...
  type BoardQuery (line 10) | type BoardQuery<T extends GameElement, A extends Record<string, Argument...
  type BoardSelection (line 12) | type BoardSelection<T extends GameElement, A extends Record<string, Argu...
  type ChoiceSelection (line 20) | type ChoiceSelection<A extends Record<string, Argument> = Record<string,...
  type NumberSelection (line 28) | type NumberSelection<A extends Record<string, Argument> = Record<string,...
  type TextSelection (line 34) | type TextSelection<A extends Record<string, Argument> = Record<string, A...
  type ButtonSelection (line 39) | type ButtonSelection = Argument;
  type SelectionDefinition (line 41) | type SelectionDefinition<A extends Record<string, Argument> = Record<str...
  type ResolvedSelection (line 94) | type ResolvedSelection = Omit<Selection, 'prompt' | 'min' | 'max' | 'ini...
  class Selection (line 109) | class Selection {
    method constructor (line 127) | constructor(name: string, s: SelectionDefinition | Selection) {
    method error (line 180) | error(args: Record<string, Argument>): string | undefined {
    method options (line 223) | options(this: ResolvedSelection): {choice: Argument, error?: string, l...
    method isUnbounded (line 233) | isUnbounded(this: ResolvedSelection): boolean {
    method isResolved (line 238) | isResolved(): this is ResolvedSelection {
    method isMulti (line 249) | isMulti() {
    method isBoardChoice (line 253) | isBoardChoice() {
    method resolve (line 257) | resolve(args: Record<string, Argument>): ResolvedSelection {
    method isPossible (line 279) | isPossible(this: ResolvedSelection): boolean {
    method isForced (line 289) | isForced(this: ResolvedSelection): Argument | undefined {
    method toString (line 306) | toString(): string {

FILE: src/action/utils.ts
  type SerializedSingleArg (line 6) | type SerializedSingleArg = string | number | boolean;
  type SerializedArg (line 7) | type SerializedArg = SerializedSingleArg | SerializedSingleArg[];
  type Serializable (line 8) | type Serializable = SingleArgument | null | undefined | Serializable[] |...

FILE: src/board/adjacency-space.ts
  method isAdjacent (line 22) | isAdjacent(_el1: GameElement, _el2: GameElement): boolean {
  method _positionOf (line 26) | _positionOf(element: GameElement) {
  method _positionedParentOf (line 31) | _positionedParentOf(element: GameElement): GameElement {
  method configureLayout (line 40) | configureLayout(layoutConfiguration: Partial<LayoutAttributes>) {

FILE: src/board/connected-space-map.ts
  class ConnectedSpaceMap (line 23) | class ConnectedSpaceMap<G extends BaseGame> extends AdjacencySpace<G> {
    method constructor (line 28) | constructor(ctx: ElementContext) {
    method isAdjacent (line 41) | isAdjacent(el1: GameElement, el2: GameElement) {
    method connect (line 58) | connect(space1: Space<G>, space2: Space<G>, distance: number = 1) {
    method connectOneWay (line 65) | connectOneWay(space1: Space<G>, space2: Space<G>, distance: number = 1) {
    method distanceBetween (line 84) | distanceBetween(el1: GameElement, el2: GameElement) {
    method _distanceBetweenNodes (line 90) | _distanceBetweenNodes(n1: string, n2: string): number {
    method allAdjacentTo (line 115) | allAdjacentTo(element: GameElement, className?: any, ...finders: Eleme...
    method allWithinDistanceOf (line 137) | allWithinDistanceOf(element: GameElement, distance: number, className?...
    method allConnectedTo (line 165) | allConnectedTo(element: GameElement, className?: any, ...finders: Elem...
    method closestTo (line 188) | closestTo<F extends GameElement>(element: GameElement, className?: any...

FILE: src/board/element-collection.ts
  type Sorter (line 16) | type Sorter<T> = keyof T | ((e: T) => number | string)
  type ElementFinder (line 42) | type ElementFinder<T extends GameElement = GameElement> = (
  class ElementCollection (line 54) | class ElementCollection<T extends GameElement = GameElement> extends Arr...
    method slice (line 56) | slice(...a: Parameters<Array<T>['slice']>):ElementCollection<T> {retur...
    method filter (line 57) | filter(...a: Parameters<Array<T>['filter']>):ElementCollection<T> {ret...
    method all (line 77) | all(className?: ElementFinder | ElementClass, ...finders: ElementFinde...
    method _finder (line 85) | _finder<F extends GameElement>(
    method first (line 149) | first(className?: ElementFinder | ElementClass, ...finders: ElementFin...
    method firstN (line 170) | firstN(n: number, className?: ElementFinder | ElementClass, ...finders...
    method last (line 188) | last(className?: ElementFinder | ElementClass, ...finders: ElementFind...
    method lastN (line 209) | lastN(n: number, className?: ElementFinder | ElementClass, ...finders:...
    method top (line 224) | top(className?: ElementFinder | ElementClass, ...finders: ElementFinde...
    method topN (line 238) | topN(n: number, className?: ElementFinder | ElementClass, ...finders: ...
    method bottom (line 253) | bottom(className?: ElementFinder | ElementClass, ...finders: ElementFi...
    method bottomN (line 267) | bottomN(n: number, className?: ElementFinder | ElementClass, ...finder...
    method showToAll (line 280) | showToAll(this: ElementCollection<Piece<BaseGame>>) {
    method showOnlyTo (line 290) | showOnlyTo(this: ElementCollection<Piece<BaseGame>>, player: Player | ...
    method showTo (line 305) | showTo(this: ElementCollection<Piece<BaseGame>>, ...player: Player[] |...
    method hideFromAll (line 322) | hideFromAll(this: ElementCollection<Piece<BaseGame>>) {
    method hideFrom (line 333) | hideFrom(this: ElementCollection<Piece<BaseGame>>, ...player: Player[]...
    method sortBy (line 353) | sortBy<E extends T>(key: Sorter<E> | Sorter<E>[], direction?: "asc" | ...
    method sortedBy (line 372) | sortedBy(key: Sorter<T> | (Sorter<T>)[], direction: "asc" | "desc" = "...
    method sum (line 385) | sum(key: ((e: T) => number) | (keyof {[K in keyof T]: T[K] extends num...
    method withHighest (line 404) | withHighest(...attributes: Sorter<T>[]): T | undefined {
    method withLowest (line 423) | withLowest(...attributes: Sorter<T>[]): T | undefined {
    method max (line 441) | max<K extends number | string>(key: {[K2 in keyof T]: T[K2] extends K ...
    method min (line 461) | min<K extends number | string>(key: {[K2 in keyof T]: T[K2] extends K ...
    method areAllEqual (line 471) | areAllEqual(key: keyof T): boolean {
    method remove (line 481) | remove() {
    method putInto (line 492) | putInto(to: GameElement, options?: {position?: number, fromTop?: numbe...
    method layout (line 507) | layout(
    method configureLayout (line 520) | configureLayout(
    method appearance (line 531) | appearance(appearance: ElementUI<T>['appearance']) {

FILE: src/board/element.ts
  type ElementJSON (line 15) | type ElementJSON = ({className: string, children?: ElementJSON[]} & Reco...
  type ElementClass (line 17) | type ElementClass<T extends GameElement = GameElement> = {
  type GenericSorter (line 29) | type GenericSorter = string | ((e: GameElement) => number | string)
  type ElementAttributes (line 35) | type ElementAttributes<T extends GameElement> =
  type ElementContext (line 38) | type ElementContext = {
  type Box (line 55) | type Box = { left: number, top: number, width: number, height: number };
  type Vector (line 60) | type Vector = { x: number, y: number };
  type Direction (line 62) | type Direction = 'up' | 'down' | 'left' | 'right'
  type DirectionWithDiagonals (line 63) | type DirectionWithDiagonals = Direction | 'upleft' | 'upright' | 'downle...
  type ElementUI (line 65) | type ElementUI<T extends GameElement> = {
  type LayoutAttributes (line 93) | type LayoutAttributes = {
  class GameElement (line 234) | class GameElement<G extends BaseGame = BaseGame, P extends BasePlayer = ...
    method constructor (line 319) | constructor(ctx: Partial<ElementContext>) {
    method toString (line 351) | toString() {
    method isVisibleTo (line 355) | isVisibleTo(_player: Player | number) {
    method isVisible (line 359) | isVisible() {
    method all (line 381) | all(className?: any, ...finders: ElementFinder[]) {
    method first (line 393) | first(className?: any, ...finders: ElementFinder[]) {
    method firstN (line 409) | firstN(n: number, className?: any, ...finders: ElementFinder[]) {
    method last (line 421) | last(className?: any, ...finders: ElementFinder[]) {
    method lastN (line 437) | lastN(n: number, className: any, ...finders: ElementFinder[]) {
    method top (line 448) | top(className?: any, ...finders: ElementFinder[]) {
    method topN (line 458) | topN(n: number, className?: any, ...finders: ElementFinder[]) {
    method bottom (line 468) | bottom(className?: any, ...finders: ElementFinder[]) {
    method bottomN (line 478) | bottomN(n: number, className?: any, ...finders: ElementFinder[]) {
    method next (line 489) | next<F extends GameElement>(this: F, ...finders: ElementFinder<F>[]): ...
    method previous (line 502) | previous<F extends GameElement>(this: F, ...finders: ElementFinder<F>[...
    method others (line 515) | others(className?: any, ...finders: ElementFinder[]) {
    method has (line 527) | has(className?: any, ...finders: ElementFinder[]) {
    method isAdjacentTo (line 540) | isAdjacentTo(element: GameElement): boolean {
    method distanceTo (line 552) | distanceTo(element: GameElement): number {
    method adjacencies (line 566) | adjacencies(className?: any, ...finders: ElementFinder[]) {
    method withinDistance (line 580) | withinDistance(distance: number, className?: any, ...finders: ElementF...
    method setOrder (line 599) | setOrder(order: typeof this._t.order) {
    method container (line 611) | container<T extends GameElement>(className?: ElementClass<T>): T | und...
    method containerWithProperty (line 622) | containerWithProperty(property: string, value?: any): GameElement | un...
    method isEmpty (line 633) | isEmpty() {
    method sortBy (line 641) | sortBy(key: GenericSorter | GenericSorter[], direction?: "asc" | "desc...
    method shuffle (line 649) | shuffle() {
    method owner (line 664) | get owner(): P | undefined {
    method mine (line 679) | get mine() {
    method create (line 700) | create<T extends GameElement>(className: ElementClass<T>, name: string...
    method createMany (line 747) | createMany<T extends GameElement>(n: number, className: ElementClass<T...
    method createElement (line 755) | createElement<T extends GameElement>(className: ElementClass<T>, name:...
    method destroy (line 774) | destroy() {
    method rotation (line 784) | get rotation() {
    method rotation (line 789) | set rotation(r: number) {
    method position (line 797) | position() {
    method branch (line 806) | branch() {
    method atBranch (line 823) | atBranch(b: string) {
    method atID (line 839) | atID(id: number): GameElement | undefined {
    method atRef (line 852) | atRef(ref: number): GameElement | undefined {
    method _cellAt (line 861) | _cellAt(pos: Vector): string | undefined {
    method _sizeNeededFor (line 869) | _sizeNeededFor(_element: GameElement) {
    method setShape (line 902) | setShape(...shape: string[]) {
    method setEdges (line 947) | setEdges(edges: Record<string, Partial<Record<Direction, string>>> | P...
    method isDescendantOf (line 963) | isDescendantOf(el: GameElement): boolean {
    method attributeList (line 967) | attributeList<T extends GameElement>(this: T): ElementAttributes<T> {
    method toJSON (line 983) | toJSON(seenBy?: number) {
    method createChildrenFromJSON (line 1018) | createChildrenFromJSON(childrenJSON: ElementJSON[], branch: string) {
    method assignAttributesFromJSON (line 1052) | assignAttributesFromJSON(childrenJSON: ElementJSON[], branch: string) {
    method resetUI (line 1077) | resetUI() {
    method layout (line 1105) | layout(
    method layoutAsDrawer (line 1157) | layoutAsDrawer(applyTo: Space<G, P> | string, attributes: {
    method layoutAsTabs (line 1185) | layoutAsTabs(tabs: Record<string, Space<G, P> | string>, attributes: {
    method layoutAsPopout (line 1213) | layoutAsPopout(applyTo: Space<G, P> | string, attributes: {
    method configureLayout (line 1226) | configureLayout(layoutConfiguration: Partial<LayoutAttributes>) {
    method appearance (line 1267) | appearance(appearance: ElementUI<this>['appearance']) {
    method childRefsIfObscured (line 1271) | childRefsIfObscured() {
    method assignChildRefs (line 1281) | assignChildRefs(refs: number[]) {
    method hasMoved (line 1287) | hasMoved(): boolean {
    method resetMovementTracking (line 1291) | resetMovementTracking() {
    method resetRefTracking (line 1296) | resetRefTracking() {

FILE: src/board/fixed-grid.ts
  method afterCreation (line 31) | afterCreation() {
  method create (line 50) | create<T extends GameElement>(_className: ElementClass, _name: string): T {
  method _adjacentGridPositionsTo (line 54) | _adjacentGridPositionsTo(_column: number, _row: number): [number, number...
  method _gridPositions (line 58) | _gridPositions(): [number, number][] {

FILE: src/board/game.ts
  type ActionLayout (line 35) | type ActionLayout = {
  type BoardSize (line 95) | type BoardSize = {
  type BoardSizeMatcher (line 105) | type BoardSizeMatcher = {
  type BaseGame (line 114) | interface BaseGame extends Game<BaseGame, BasePlayer> {}
  class Game (line 124) | class Game<G extends BaseGame = BaseGame, P extends BasePlayer = BasePla...
    method constructor (line 151) | constructor(ctx: Partial<ElementContext>) {
    method registerClasses (line 161) | registerClasses(...classList: ElementClass[]) {
    method defineFlow (line 178) | defineFlow(...flow: FlowStep[]) {
    method defineSubflow (line 190) | defineSubflow(name: string, ...flow: FlowStep[]) {
    method defineActions (line 204) | defineActions(actions: Record<string, (player: P) => Action<Record<str...
    method setting (line 214) | setting(key: string) {
    method action (line 268) | action<A extends Record<string, Argument> = NonNullable<unknown>>(defi...
    method followUp (line 303) | followUp(action: ActionStub) {
    method finish (line 348) | finish(winner?: P | P[], announcement?: string) {
    method getWinners (line 358) | getWinners() {
    method addDelay (line 369) | addDelay() {
    method message (line 402) | message(text: string, args?: Record<string, Argument>) {
    method messageTo (line 429) | messageTo(player: (BasePlayer | number) | (BasePlayer | number)[], tex...
    method announce (line 453) | announce(announcement: string) {
    method allJSON (line 460) | allJSON(seenBy?: number): ElementJSON[] {
    method fromJSON (line 467) | fromJSON(boardJSON: ElementJSON[]) {
    method resetUI (line 515) | resetUI() {
    method setBoardSize (line 520) | setBoardSize(boardSize: BoardSize) {
    method getBoardSize (line 526) | getBoardSize(screenX: number, screenY: number, mobile: boolean) {
    method layoutControls (line 543) | layoutControls(attributes: ActionLayout) {
    method layoutStep (line 556) | layoutStep(step: string, attributes: ActionLayout) {
    method layoutAction (line 570) | layoutAction(action: string, attributes: ActionLayout) {
    method disableDefaultAppearance (line 580) | disableDefaultAppearance() {
    method showLayoutBoundingBoxes (line 589) | showLayoutBoundingBoxes() {

FILE: src/board/hex-grid.ts
  class HexGrid (line 16) | class HexGrid<G extends Game> extends FixedGrid<G> {
    method _adjacentGridPositionsTo (line 67) | _adjacentGridPositionsTo(column: number, row: number): [number, number...
    method _gridPositions (line 92) | _gridPositions(): [number, number][] {
    method _cornerPositions (line 118) | _cornerPositions(): [number, number][] {

FILE: src/board/index.ts
  function union (line 24) | function union<T extends GameElement>(...queries: (T | ElementCollection...

FILE: src/board/piece-grid.ts
  class PieceGrid (line 19) | class PieceGrid<G extends Game> extends AdjacencySpace<G> {
    method constructor (line 58) | constructor(ctx: ElementContext) {
    method isAdjacent (line 63) | isAdjacent(el1: GameElement, el2: GameElement): boolean {
    method _sizeNeededFor (line 67) | _sizeNeededFor(element: GameElement) {
    method cellsAround (line 80) | cellsAround(piece: Piece<G>, pos: Vector) {
    method isOverlapping (line 97) | isOverlapping(piece: Piece<G>, other?: Piece<G>): boolean {
    method _fitPieceInFreePlace (line 127) | _fitPieceInFreePlace(piece: Piece<G>, rows: number, columns: number, o...
    method adjacenciesByCell (line 201) | adjacenciesByCell(piece: Piece<G>, other?: Piece<G>): {piece: Piece<G>...
    method adjacenciesByEdge (line 287) | adjacenciesByEdge(piece: Piece<G>, other?: Piece<G>): {piece: Piece<G>...

FILE: src/board/piece.ts
  class Piece (line 13) | class Piece<G extends Game, P extends Player = NonNullable<G['player']>>...
    method createElement (line 20) | createElement<T extends GameElement>(className: ElementClass<T>, name:...
    method showToAll (line 31) | showToAll() {
    method showOnlyTo (line 39) | showOnlyTo(player: Player | number) {
    method showTo (line 52) | showTo(...player: Player[] | number[]) {
    method hideFromAll (line 67) | hideFromAll() {
    method hideFrom (line 76) | hideFrom(...player: Player[] | number[]) {
    method isVisibleTo (line 94) | isVisibleTo(player: Player | number) {
    method isVisible (line 110) | isVisible() {
    method revealWhenHidden (line 126) | static revealWhenHidden<T extends Piece<BaseGame>>(this: ElementClass<...
    method putInto (line 144) | putInto(to: GameElement, options?: {position?: number, row?: number, c...
    method cloneInto (line 170) | cloneInto<T extends GameElement>(this: T, into: GameElement): T {
    method remove (line 192) | remove() {

FILE: src/board/single-layout.ts
  method layout (line 26) | layout() {
  method resetUI (line 30) | resetUI() {

FILE: src/board/space.ts
  type ElementEventHandler (line 8) | type ElementEventHandler<T extends GameElement> = {callback: (el: T) => ...
  class Space (line 15) | class Space<G extends BaseGame, P extends Player = NonNullable<G['player...
    method contentsWillBeShown (line 35) | contentsWillBeShown() {
    method contentsWillBeShownToOwner (line 43) | contentsWillBeShownToOwner() {
    method contentsWillBeShownTo (line 51) | contentsWillBeShownTo(...players: P[]) {
    method contentsWillBeHidden (line 59) | contentsWillBeHidden() {
    method contentsWillBeHiddenFrom (line 67) | contentsWillBeHiddenFrom(...players: P[]) {
    method blockViewFor (line 80) | blockViewFor(players: 'all' | 'none' | 'all-but-owner' | Player[]) {
    method isSpace (line 84) | isSpace() { return true; }
    method create (line 86) | create<T extends GameElement>(className: ElementClass<T>, name: string...
    method addEventHandler (line 92) | addEventHandler<T extends GameElement>(type: keyof Space<G>['_eventHan...
    method onEnter (line 109) | onEnter<T extends GameElement>(type: ElementClass<T>, callback: (el: T...
    method onExit (line 125) | onExit<T extends GameElement>(type: ElementClass<T>, callback: (el: T)...
    method triggerEvent (line 129) | triggerEvent(event: keyof Space<G>['_eventHandlers'], element: Piece<G...

FILE: src/board/square-grid.ts
  class SquareGrid (line 14) | class SquareGrid<G extends Game> extends FixedGrid<G> {
    method _adjacentGridPositionsTo (line 22) | _adjacentGridPositionsTo(column: number, row: number): [number, number...
    method _gridPositions (line 43) | _gridPositions(): [number, number][] {

FILE: src/board/stack.ts
  class Stack (line 14) | class Stack<G extends BaseGame> extends SingleLayout<G> {
    method afterCreation (line 28) | afterCreation() {

FILE: src/board/utils.ts
  function rotateDirection (line 3) | function rotateDirection(dir: Direction, rotation: number) {

FILE: src/components/d6/d6.ts
  class D6 (line 14) | class D6<G extends Game = Game> extends Piece<G> {
    method roll (line 28) | roll() {

FILE: src/flow/action-step.ts
  type ActionStepPosition (line 10) | type ActionStepPosition = { // turn taken by `player`
  class ActionStep (line 16) | class ActionStep extends Flow {
    method constructor (line 33) | constructor({ name, player, players, actions, prompt, description, opt...
    method reset (line 67) | reset() {
    method thisStepArgs (line 71) | thisStepArgs() {
    method setPosition (line 78) | setPosition(position: ActionStepPosition, sequence?: number) {
    method getPlayers (line 86) | getPlayers() {
    method awaitingAction (line 93) | awaitingAction() {
    method currentBlock (line 97) | currentBlock() {
    method allowedActions (line 106) | allowedActions(): string[] {
    method actionNeeded (line 110) | actionNeeded(player?: Player): {
    method processMove (line 137) | processMove(move: {
    method playOneStep (line 185) | playOneStep(): InterruptSignal[] | FlowControl | Flow {
    method advance (line 189) | advance() {
    method toJSON (line 195) | toJSON(forPlayer=true) {
    method fromJSON (line 207) | fromJSON(position: any) {
    method allSteps (line 215) | allSteps() {
    method toString (line 219) | toString(): string {
    method visualize (line 223) | visualize(top: Flow) {

FILE: src/flow/each-player.ts
  class EachPlayer (line 8) | class EachPlayer<P extends Player> extends ForLoop<P> {
    method constructor (line 12) | constructor({ name, startingPlayer, nextPlayer, turns, continueUntil, ...
    method setPosition (line 40) | setPosition(position: typeof this.position, sequence?: number, reset=t...
    method toJSON (line 47) | toJSON() {
    method fromJSON (line 54) | fromJSON(position: any) {
    method allSteps (line 61) | allSteps() {
    method toString (line 65) | toString(): string {
    method visualize (line 69) | visualize(top: Flow) {

FILE: src/flow/enums.ts
  type LoopInterruptSignal (line 63) | type LoopInterruptSignal = { signal: InterruptControl.repeat | Interrupt...
  type SubflowSignal (line 64) | type SubflowSignal = { signal: InterruptControl.subflow, data: {name: st...
  type InterruptSignal (line 65) | type InterruptSignal = LoopInterruptSignal | SubflowSignal
  function interrupt (line 70) | function interrupt({ signal, data }: InterruptSignal) {
  type InterruptControl (line 83) | enum InterruptControl {
  type FlowControl (line 91) | enum FlowControl {

FILE: src/flow/every-player.ts
  type EveryPlayerPosition (line 9) | type EveryPlayerPosition = {positions: FlowBranchJSON[][], sequences: nu...
  class EveryPlayer (line 11) | class EveryPlayer<P extends Player> extends Flow {
    method constructor (line 19) | constructor({ players, do: block, name }: {
    method reset (line 28) | reset() {
    method thisStepArgs (line 34) | thisStepArgs() {
    method withPlayer (line 43) | withPlayer<T>(value: number, fn: () => T, mutate=false): T {
    method getPlayers (line 59) | getPlayers(): P[] {
    method branchJSON (line 64) | branchJSON(forPlayer=true): FlowBranchJSON[] {
    method setPosition (line 81) | setPosition(positionJSON: any, sequence?: number) {
    method currentBlock (line 101) | currentBlock() {
    method actionNeeded (line 107) | actionNeeded(player?: Player) {
    method processMove (line 113) | processMove(move: {
    method playOneStep (line 128) | playOneStep(): InterruptSignal[] | FlowControl | Flow {
    method toString (line 147) | toString(): string {
    method visualize (line 151) | visualize(top: Flow) {

FILE: src/flow/flow.ts
  type FlowArguments (line 45) | type FlowArguments = Record<string, any>;
  type FlowStep (line 54) | type FlowStep = Flow | ((args: FlowArguments) => any);
  type FlowDefinition (line 64) | type FlowDefinition = FlowStep | FlowStep[]
  type FlowBranchNode (line 66) | type FlowBranchNode = ({
  type FlowBranchJSON (line 88) | type FlowBranchJSON = ({
  type Position (line 96) | type Position = (
  type FlowVisualization (line 100) | type FlowVisualization = {
  class Flow (line 112) | class Flow {
    method constructor (line 124) | constructor({ name, do: block }: { name?: string, do?: FlowDefinition ...
    method validateNoDuplicate (line 131) | validateNoDuplicate() {
    method flowStepArgs (line 138) | flowStepArgs(): FlowArguments {
    method thisStepArgs (line 148) | thisStepArgs() {
    method branchJSON (line 154) | branchJSON(forPlayer=true): FlowBranchJSON[] {
    method setBranchFromJSON (line 166) | setBranchFromJSON(branch: FlowBranchJSON[]) {
    method setPosition (line 178) | setPosition(position: any, sequence?: number, reset=true) {
    method setPositionFromJSON (line 200) | setPositionFromJSON(positionJSON: any, sequence?: number) {
    method currentLoop (line 204) | currentLoop(name?: string): WhileLoop | undefined {
    method currentProcessor (line 209) | currentProcessor(): Flow | undefined {
    method actionNeeded (line 214) | actionNeeded(player?: Player): {
    method processMove (line 225) | processMove(move: NonNullable<ActionStepPosition>): string | SubflowSi...
    method getStep (line 232) | getStep(name: string): Flow | undefined {
    method playOneStep (line 253) | playOneStep(): InterruptSignal[] | FlowControl | Flow {
    method play (line 283) | play() {
    method reset (line 301) | reset() {
    method currentBlock (line 306) | currentBlock(): FlowDefinition | undefined {
    method toJSON (line 311) | toJSON(_forPlayer=true): any {
    method fromJSON (line 316) | fromJSON(json: any): typeof this.position {
    method advance (line 321) | advance(): FlowControl {
    method allSteps (line 326) | allSteps(): FlowDefinition | undefined {
    method toString (line 330) | toString() {
    method stacktrace (line 334) | stacktrace(indent=0) {
    method visualize (line 340) | visualize(top: Flow) {
    method visualizeBlocks (line 351) | visualizeBlocks({ type, blocks, name, top, block, position }: {

FILE: src/flow/for-each.ts
  type ForEachPosition (line 9) | type ForEachPosition<T> = ForLoopPosition<T> & { collection: T[] };
  class ForEach (line 11) | class ForEach<T extends Serializable> extends ForLoop<T> {
    method constructor (line 17) | constructor({ name, collection, do: block }: {
    method reset (line 33) | reset() {
    method toJSON (line 38) | toJSON(forPlayer=true) {
    method fromJSON (line 46) | fromJSON(position: any) {
    method toString (line 54) | toString(): string {
    method visualize (line 58) | visualize(top: Flow) {

FILE: src/flow/for-loop.ts
  type ForLoopPosition (line 7) | type ForLoopPosition<T> = { index: number, value: T };
  class ForLoop (line 9) | class ForLoop<T = Serializable> extends WhileLoop {
    method constructor (line 17) | constructor({ name, initial, next, do: block, while: whileCondition }: {
    method currentBlock (line 31) | currentBlock() {
    method toString (line 35) | toString(): string {
    method visualize (line 39) | visualize(top: Flow) {

FILE: src/flow/if-else.ts
  class If (line 6) | class If extends SwitchCase<boolean> {
    method constructor (line 7) | constructor({ name, if: test, do: doExpr, else: elseExpr }: {
    method toString (line 16) | toString(): string {
    method visualize (line 20) | visualize(top: Flow) {

FILE: src/flow/switch-case.ts
  type SwitchCasePostion (line 8) | type SwitchCasePostion<T> = { index?: number, value?: T, default?: boole...
  type SwitchCaseCases (line 9) | type SwitchCaseCases<T> = ({eq: T, do: FlowDefinition} | {test: (a: T) =...
  class SwitchCase (line 11) | class SwitchCase<T extends Serializable> extends Flow {
    method constructor (line 18) | constructor({ name, switch: switchExpr, cases, default: def }: {
    method reset (line 30) | reset() {
    method currentBlock (line 44) | currentBlock() {
    method toJSON (line 51) | toJSON(forPlayer=true) {
    method fromJSON (line 59) | fromJSON(position: any) {
    method allSteps (line 67) | allSteps(): FlowDefinition {
    method toString (line 73) | toString(): string {
    method visualize (line 77) | visualize(top: Flow) {

FILE: src/flow/while-loop.ts
  type WhileLoopPosition (line 7) | type WhileLoopPosition = { index: number, value?: any };
  class WhileLoop (line 9) | class WhileLoop extends Flow {
    method constructor (line 17) | constructor({ do: block, while: whileCondition }: {
    method reset (line 25) | reset() {
    method currentBlock (line 36) | currentBlock() {
    method advance (line 40) | advance() {
    method repeat (line 52) | repeat() {
    method exit (line 58) | exit(): FlowControl.complete {
    method interrupt (line 63) | interrupt(signal: InterruptControl) {
    method allSteps (line 69) | allSteps() {
    method toString (line 73) | toString(): string {
    method visualize (line 77) | visualize(top: Flow) {

FILE: src/game-creator.ts
  type SetupFunction (line 8) | type SetupFunction<G extends Game = Game> = (

FILE: src/game-manager.ts
  type PlayerAttributes (line 24) | type PlayerAttributes<T extends Player = Player> = {
  type Move (line 32) | type Move = {
  type PendingMove (line 38) | type PendingMove = {
  type SerializedMove (line 45) | type SerializedMove = {
  type Message (line 50) | type Message = {
  type ActionDebug (line 55) | type ActionDebug = Record<string, {
  type FlowStackJSON (line 61) | type FlowStackJSON = {
  class GameManager (line 73) | class GameManager<G extends BaseGame = BaseGame, P extends BasePlayer = ...
    method constructor (line 103) | constructor(playerClass: {new(...a: any[]): P}, gameClass: ElementClas...
    method setSettings (line 114) | setSettings(settings: Record<string, any>) {
    method setRandomSeed (line 118) | setRandomSeed(rseed: string) {
    method start (line 130) | start() {
    method play (line 141) | play(): void {
    method flow (line 175) | flow() {
    method getFlowStep (line 179) | getFlowStep(name: string) {
    method beginSubflow (line 186) | beginSubflow(flow: SubflowSignal['data']) {
    method setFlowFromJSON (line 209) | setFlowFromJSON(json: FlowStackJSON[]) {
    method startFlow (line 216) | startFlow(flowState: FlowStackJSON) {
    method flowJSON (line 236) | flowJSON(player: boolean = false) {
    method getState (line 254) | getState(player?: P): GameState {
    method getPlayerStates (line 267) | getPlayerStates(): PlayerState[] {
    method getUpdate (line 276) | getUpdate(): GameUpdate {
    method contextualizeBoardToPlayer (line 303) | contextualizeBoardToPlayer(player?: Player) {
    method inContextOfPlayer (line 309) | inContextOfPlayer<T>(player: Player, fn: () => T): T {
    method trackMovement (line 316) | trackMovement(track=true) {
    method getAction (line 327) | getAction(name: string, player: P) {
    method godModeActions (line 348) | godModeActions(): Record<string, Action> {
    method processMove (line 389) | processMove({ player, name, args }: Move): string | undefined {
    method allowedActions (line 411) | allowedActions(player: P, debug?: ActionDebug): {
    method getPendingMoves (line 453) | getPendingMoves(player: P, name?: string, args?: Record<string, Argume...

FILE: src/interface.ts
  type SetupState (line 12) | type SetupState = {
  type GameState (line 18) | type GameState = {
  type GameStartedState (line 29) | type GameStartedState = {
  type GameFinishedState (line 35) | type GameFinishedState = {
  type PlayerState (line 41) | type PlayerState = {
  type GameUpdate (line 48) | type GameUpdate = {
  type ReprocessHistoryResult (line 54) | type ReprocessHistoryResult = {
  type SerializedInterfaceMove (line 60) | type SerializedInterfaceMove = {
  type GameInterface (line 65) | type GameInterface = {
  function advanceRseed (line 79) | function advanceRseed(rseed?: string) {
  method reprocessHistory (line 157) | reprocessHistory(state: SetupState, moves: SerializedInterfaceMove[]): R...

FILE: src/player/collection.ts
  class PlayerCollection (line 18) | class PlayerCollection<P extends Player> extends Array<P> {
    method addPlayer (line 29) | addPlayer(attrs: PlayerAttributes & Record<string, any>) {
    method atPosition (line 41) | atPosition(position: number) {
    method current (line 49) | current(): P | undefined {
    method allCurrent (line 57) | allCurrent(): P[] {
    method host (line 64) | host(): P {
    method notCurrent (line 71) | notCurrent() {
    method inPositionOrder (line 79) | inPositionOrder() {
    method setCurrent (line 89) | setCurrent(players: number | P | number[] | P[]) {
    method next (line 98) | next() {
    method after (line 110) | after(player: number | P) {
    method seatedNext (line 118) | seatedNext(player: P, steps = 1) {
    method turnOrderOf (line 127) | turnOrderOf(player: number | P) {
    method sortBy (line 141) | sortBy(key: Sorter<P> | (Sorter<P>)[], direction?: "asc" | "desc") {
    method sortedBy (line 159) | sortedBy(key: Sorter<P> | (Sorter<P>)[], direction: "asc" | "desc" = "...
    method sum (line 163) | sum(key: ((e: P) => number) | (keyof {[K in keyof P]: P[K] extends num...
    method withHighest (line 167) | withHighest(...attributes: Sorter<P>[]) {
    method withLowest (line 171) | withLowest(...attributes: Sorter<P>[]) {
    method shuffle (line 175) | shuffle() {
    method max (line 179) | max<K extends keyof P>(key: K): P[K] {
    method min (line 183) | min<K extends keyof P>(key: K): P[K] {
    method fromJSON (line 187) | fromJSON(players: Record<string, any>[]) {
    method assignAttributesFromJSON (line 196) | assignAttributesFromJSON(players: PlayerAttributes[]) {

FILE: src/player/player.ts
  type BasePlayer (line 9) | interface BasePlayer extends Player<BaseGame, BasePlayer> {}
  class Player (line 18) | class Player<G extends BaseGame = BaseGame, P extends BasePlayer = BaseP...
    method hide (line 59) | static hide<P extends BasePlayer>(this: {new(): P; hiddenAttributes: s...
    method isCurrent (line 65) | isCurrent() {
    method setCurrent (line 72) | setCurrent(this: P) {
    method others (line 79) | others(): P[] {
    method other (line 86) | other(): P {
    method allMy (line 98) | allMy(className?: any, ...finders: ElementFinder[]) {
    method my (line 109) | my(className?: any, ...finders: ElementFinder[]) {
    method has (line 120) | has(className?: any, ...finders: ElementFinder[]): boolean {
    method toJSON (line 124) | toJSON(player?: Player) {
    method toString (line 148) | toString() {

FILE: src/test-runner.ts
  type Window (line 12) | interface Window {
  class TestRunnerPlayer (line 17) | class TestRunnerPlayer<G extends BaseGame> {
    method constructor (line 25) | constructor(runner: TestRunner<G>, position: number, store: ReturnType...
    method move (line 33) | move(name: string, args: Record<string, Argument>) {
    method actions (line 49) | actions() {
  class TestRunner (line 56) | class TestRunner<G extends BaseGame> {
    method constructor (line 68) | constructor(private setup: SetupFunction, mocks?: (game: G) => void) {
    method start (line 100) | start({players, settings}: {
    method getCurrentGame (line 130) | getCurrentGame() {
    method updatePlayers (line 135) | updatePlayers() {
    method updatePlayersFromState (line 140) | updatePlayersFromState() {

FILE: src/test/fixtures/games.ts
  class TestPlayer (line 9) | class TestPlayer extends Player<TestGame, TestPlayer> {
  class TestGame (line 13) | class TestGame extends Game<TestGame, TestPlayer> {
  class Token (line 17) | class Token extends Piece<TestGame> {

FILE: src/test/game_manager_test.ts
  class TestPlayer (line 22) | class TestPlayer extends Player<TestGame, TestPlayer> {
  class TestGame (line 28) | class TestGame extends Game<TestGame, TestPlayer> {
  class Card (line 32) | class Card extends Piece<TestGame> {
  class Country (line 38) | class Country extends Space<TestGame> {
  class General (line 42) | class General extends Piece<TestGame> {

FILE: src/test/game_test.ts
  class Country (line 150) | class Country extends Space<Game> {
  class Country (line 167) | class Country extends Space<Game> {
  class General (line 170) | class General extends Piece<Game> {
  class Card (line 229) | class Card extends Piece<Game> {
  class Cell (line 746) | class Cell extends Space<Game> { color: string }

FILE: src/test/render_test.ts
  class Country (line 326) | class Country extends Space<Game> { }

FILE: src/test/ui_test.ts
  function getGameStore (line 271) | function getGameStore(gameCreator: (game: Game) => void) {
  function updateStore (line 278) | function updateStore(store: ReturnType<typeof createGameStore>, players:...

FILE: src/ui/Main.tsx
  type User (line 10) | type User = {
  type UsersEvent (line 23) | type UsersEvent = {
  type UserOnlineEvent (line 28) | type UserOnlineEvent = {
  type GameSettings (line 34) | type GameSettings = Record<string, any>
  type SettingsUpdateEvent (line 37) | type SettingsUpdateEvent = {
  type GameUpdateEvent (line 43) | type GameUpdateEvent = {
  type GameFinishedEvent (line 50) | type GameFinishedEvent = {
  type MessageProcessedEvent (line 58) | type MessageProcessedEvent = {
  type SeatOperation (line 64) | type SeatOperation = {
  type UnseatOperation (line 73) | type UnseatOperation = {
  type UpdateOperation (line 78) | type UpdateOperation = {
  type PlayerOperation (line 87) | type PlayerOperation = SeatOperation | UnseatOperation | UpdateOperation
  type UpdatePlayersMessage (line 89) | type UpdatePlayersMessage = {
  type UpdateSettingsMessage (line 95) | type UpdateSettingsMessage = {
  type StartMessage (line 103) | type StartMessage = {
  type ReadyMessage (line 109) | type ReadyMessage = {
  type SwitchPlayerMessage (line 113) | type SwitchPlayerMessage = {

FILE: src/ui/game/components/ProfileBadge.tsx
  function ProfileBadge (line 14) | function ProfileBadge({player}: {player: Player}) {

FILE: src/ui/lib.ts
  type GamePendingMoves (line 16) | type GamePendingMoves = ReturnType<GameManager['getPendingMoves']>;
  type UIMove (line 18) | type UIMove = PendingMove & {
  type MoveMessage (line 23) | type MoveMessage = {
  class NoRandomAllowed (line 35) | class NoRandomAllowed extends Error {}
  function updateSelections (line 45) | function updateSelections(store: GameStore): GameStore {
  function updateControls (line 261) | function updateControls(store: GameStore): Pick<GameStore, "controls"> {
  function updateBoardSelections (line 376) | function updateBoardSelections(store: GameStore): Pick<GameStore, "board...
  function updatePrompts (line 421) | function updatePrompts(store: GameStore): Partial<GameStore> {
  function removePlacementPiece (line 450) | function removePlacementPiece(placement: NonNullable<GameStore['placemen...
  function decorateUIMove (line 455) | function decorateUIMove(move: PendingMove | UIMove): UIMove {
  function clearMove (line 468) | function clearMove(): Partial<GameStore> {

FILE: src/ui/queue.ts
  class Queue (line 1) | class Queue {
    method constructor (line 7) | constructor(
    method schedule (line 12) | schedule(update: () => any, waitIfProcessing = false) {
    method pump (line 19) | pump() {
    method pause (line 32) | pause() {
    method resume (line 36) | resume() {

FILE: src/ui/render.ts
  type UIRender (line 11) | type UIRender = {
  type UI (line 51) | type UI = {
  function applyLayouts (line 64) | function applyLayouts(game: Game, base?: (b: Game) => void): UI {
  function applyDOMKeys (line 100) | function applyDOMKeys(render: UIRender, ui: UI, oldUI: UI) {
  function applyDiff (line 118) | function applyDiff(render: UIRender, ui: UI, oldUI: UI): boolean {
  function calcLayouts (line 263) | function calcLayouts(el: GameElement, ui: UI): UIRender['layouts'] {
  function applyBaseStyles (line 843) | function applyBaseStyles(render: UIRender, element: GameElement) {
  function getLayoutItems (line 875) | function getLayoutItems(el: GameElement) {
  function getArea (line 920) | function getArea(absolutePosition: Box, margin?: number | { top: number,...
  function translate (line 944) | function translate(original: Box, transform: Box): Box {
  function cellBoxRC (line 953) | function cellBoxRC(
  function cellSizeForArea (line 985) | function cellSizeForArea(
  function getTotalArea (line 1016) | function getTotalArea(

FILE: src/ui/setup/components/settingComponents.tsx
  type SetupComponentProps (line 5) | type SetupComponentProps = {

FILE: src/ui/store.ts
  type GameStore (line 33) | type GameStore = {
  type SetupComponentProps (line 398) | type SetupComponentProps = {