@logic-pad/core 0.1.0

package/dist/data/symbols/viewpointSymbol.d.ts

@@ -0,0 +1,31 @@
+import { AnyConfig } from '../config';
+import GridData from '../grid';
+import NumberSymbol from './numberSymbol';
+export default class ViewpointSymbol extends NumberSymbol {
+    private static readonly CONFIGS;
+    private static readonly EXAMPLE_GRID;
+    /**
+     * **Viewpoint Numbers count visible cells in the four directions**
+     * @param x - The x-coordinate of the symbol.
+     * @param y - The y-coordinate of the symbol.
+     * @param number - The viewpoint number.
+     */
+    constructor(x: number, y: number, number: number);
+    get id(): string;
+    get placementStep(): number;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    private countForColor;
+    countTiles(grid: GridData): {
+        completed: number;
+        possible: number;
+    };
+    copyWith({ x, y, number, }: {
+        x?: number;
+        y?: number;
+        number?: number;
+    }): this;
+    withNumber(number: number): this;
+}
+export declare const instance: ViewpointSymbol;

package/dist/data/symbols/viewpointSymbol.js

@@ -0,0 +1,106 @@
+import { ConfigType } from '../config';
+import GridData from '../grid';
+import { move } from '../dataHelper';
+import { Color, DIRECTIONS } from '../primitives';
+import NumberSymbol from './numberSymbol';
+class ViewpointSymbol extends NumberSymbol {
+    /**
+     * **Viewpoint Numbers count visible cells in the four directions**
+     * @param x - The x-coordinate of the symbol.
+     * @param y - The y-coordinate of the symbol.
+     * @param number - The viewpoint number.
+     */
+    constructor(x, y, number) {
+        super(x, y, number);
+    }
+    get id() {
+        return `viewpoint`;
+    }
+    get placementStep() {
+        return 1;
+    }
+    get explanation() {
+        return '*Viewpoint Numbers* count visible cells in the four directions';
+    }
+    get configs() {
+        return ViewpointSymbol.CONFIGS;
+    }
+    createExampleGrid() {
+        return ViewpointSymbol.EXAMPLE_GRID;
+    }
+    countForColor(grid, color, pos) {
+        let minSize = 1;
+        let maxSize = 1;
+        for (const direction of DIRECTIONS) {
+            let continuous = true;
+            grid.iterateDirection(move(pos, direction), direction, tile => tile.color === color || tile.color === Color.Gray, tile => {
+                maxSize++;
+                if (tile.color === Color.Gray) {
+                    continuous = false;
+                }
+                else {
+                    if (continuous)
+                        minSize++;
+                }
+            });
+        }
+        return { completed: minSize, possible: maxSize };
+    }
+    countTiles(grid) {
+        if (Math.floor(this.x) !== this.x || Math.floor(this.y) !== this.y)
+            return { completed: 0, possible: Number.MAX_SAFE_INTEGER };
+        const pos = { x: this.x, y: this.y };
+        const color = grid.getTile(this.x, this.y).color;
+        if (color === Color.Gray) {
+            const dark = this.countForColor(grid, Color.Dark, pos);
+            const light = this.countForColor(grid, Color.Light, pos);
+            return {
+                completed: Math.min(dark.completed, light.completed),
+                possible: Math.max(dark.possible, light.possible),
+            };
+        }
+        return this.countForColor(grid, color, pos);
+    }
+    copyWith({ x, y, number, }) {
+        return new ViewpointSymbol(x ?? this.x, y ?? this.y, number ?? this.number);
+    }
+    withNumber(number) {
+        return this.copyWith({ number });
+    }
+}
+Object.defineProperty(ViewpointSymbol, "CONFIGS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze([
+        {
+            type: ConfigType.Number,
+            default: 0,
+            field: 'x',
+            description: 'X',
+            configurable: false,
+        },
+        {
+            type: ConfigType.Number,
+            default: 0,
+            field: 'y',
+            description: 'Y',
+            configurable: false,
+        },
+        {
+            type: ConfigType.Number,
+            default: 1,
+            field: 'number',
+            description: 'Number',
+            configurable: true,
+        },
+    ])
+});
+Object.defineProperty(ViewpointSymbol, "EXAMPLE_GRID", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(GridData.create(['bbbbb', 'wwwwb', 'bwwbb', 'bbwww']).addSymbol(new ViewpointSymbol(1, 1, 5)))
+});
+export default ViewpointSymbol;
+export const instance = new ViewpointSymbol(0, 0, 1);

package/dist/data/tile.d.ts

@@ -0,0 +1,26 @@
+import { Color } from './primitives';
+export default class TileData {
+    readonly exists: boolean;
+    readonly fixed: boolean;
+    readonly color: Color;
+    constructor(exists: boolean, fixed: boolean, color: Color);
+    /**
+     * Create a gray tile.
+     */
+    static empty(): TileData;
+    /**
+     * Create a non-existent tile.
+     */
+    static doesNotExist(): TileData;
+    copyWith({ exists, fixed, color, }: {
+        exists?: boolean;
+        fixed?: boolean;
+        color?: Color;
+    }): this;
+    withExists(exists: boolean): this;
+    withFixed(fixed: boolean): this;
+    withColor(color: Color): this;
+    get isFixed(): boolean;
+    equals(other: TileData): boolean;
+    static create(char: string): TileData;
+}

package/dist/data/tile.js

@@ -0,0 +1,68 @@
+import { Color } from './primitives';
+export default class TileData {
+    constructor(exists, fixed, color) {
+        Object.defineProperty(this, "exists", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: exists
+        });
+        Object.defineProperty(this, "fixed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: fixed
+        });
+        Object.defineProperty(this, "color", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: color
+        });
+        this.exists = exists;
+        this.fixed = fixed;
+        this.color = color;
+    }
+    /**
+     * Create a gray tile.
+     */
+    static empty() {
+        return new TileData(true, false, Color.Gray);
+    }
+    /**
+     * Create a non-existent tile.
+     */
+    static doesNotExist() {
+        return new TileData(false, false, Color.Gray);
+    }
+    copyWith({ exists, fixed, color, }) {
+        return new TileData(exists ?? this.exists, fixed ?? this.fixed, color ?? this.color);
+    }
+    withExists(exists) {
+        return this.copyWith({ exists });
+    }
+    withFixed(fixed) {
+        return this.copyWith({ fixed });
+    }
+    withColor(color) {
+        return this.copyWith({ color });
+    }
+    get isFixed() {
+        return this.fixed;
+    }
+    equals(other) {
+        return (this.exists === other.exists &&
+            this.fixed === other.fixed &&
+            this.color === other.color);
+    }
+    static create(char) {
+        const exists = char !== '.';
+        const fixed = char.toUpperCase() === char;
+        const color = char.toLowerCase() === 'n'
+            ? Color.Gray
+            : char.toLowerCase() === 'b'
+                ? Color.Dark
+                : Color.Light;
+        return new TileData(exists, fixed, color);
+    }
+}

package/dist/data/tileConnections.d.ts

@@ -0,0 +1,25 @@
+export default class TileConnections {
+    [y: number]: {
+        [x: number]: boolean;
+    };
+    constructor();
+    get topLeft(): boolean;
+    set topLeft(value: boolean);
+    get top(): boolean;
+    set top(value: boolean);
+    get topRight(): boolean;
+    set topRight(value: boolean);
+    get left(): boolean;
+    set left(value: boolean);
+    get center(): boolean;
+    set center(value: boolean);
+    get right(): boolean;
+    set right(value: boolean);
+    get bottomLeft(): boolean;
+    set bottomLeft(value: boolean);
+    get bottom(): boolean;
+    set bottom(value: boolean);
+    get bottomRight(): boolean;
+    set bottomRight(value: boolean);
+    equals(other: TileConnections): boolean;
+}

package/dist/data/tileConnections.js

@@ -0,0 +1,74 @@
+export default class TileConnections {
+    constructor() {
+        for (let i = -1; i <= 1; i++) {
+            this[i] = {};
+            for (let j = -1; j <= 1; j++) {
+                this[i][j] = false;
+            }
+        }
+    }
+    get topLeft() {
+        return this[-1][-1];
+    }
+    set topLeft(value) {
+        this[-1][-1] = value;
+    }
+    get top() {
+        return this[-1][0];
+    }
+    set top(value) {
+        this[-1][0] = value;
+    }
+    get topRight() {
+        return this[-1][1];
+    }
+    set topRight(value) {
+        this[-1][1] = value;
+    }
+    get left() {
+        return this[0][-1];
+    }
+    set left(value) {
+        this[0][-1] = value;
+    }
+    get center() {
+        return this[0][0];
+    }
+    set center(value) {
+        this[0][0] = value;
+    }
+    get right() {
+        return this[0][1];
+    }
+    set right(value) {
+        this[0][1] = value;
+    }
+    get bottomLeft() {
+        return this[1][-1];
+    }
+    set bottomLeft(value) {
+        this[1][-1] = value;
+    }
+    get bottom() {
+        return this[1][0];
+    }
+    set bottom(value) {
+        this[1][0] = value;
+    }
+    get bottomRight() {
+        return this[1][1];
+    }
+    set bottomRight(value) {
+        this[1][1] = value;
+    }
+    equals(other) {
+        for (let i = -1; i <= 1; i++) {
+            for (let j = -1; j <= 1; j++) {
+                if (this[i][j] !== other[i][j]) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}

package/dist/data/validate.d.ts

@@ -0,0 +1,5 @@
+import GridData from './grid';
+import { GridState, RuleState, State } from './primitives';
+export declare function aggregateState(rules: RuleState[], grid: GridData, symbols: Map<string, State[]>): State;
+export declare function applyFinalOverrides(grid: GridData, solution: GridData | null, state: GridState): GridState;
+export default function validateGrid(grid: GridData, solution: GridData | null): GridState;

package/dist/data/validate.js

@@ -0,0 +1,131 @@
+import { handlesFinalValidation } from './events/onFinalValidation';
+import { handlesSymbolValidation } from './events/onSymbolValidation';
+import { Color, State } from './primitives';
+export function aggregateState(rules, grid, symbols) {
+    if (rules.some(s => s.state === State.Error))
+        return State.Error;
+    for (const [_, symbolList] of symbols) {
+        if (symbolList.some(s => s === State.Error))
+            return State.Error;
+    }
+    if (rules.some((s, idx) => s.state === State.Incomplete && grid.rules[idx].necessaryForCompletion))
+        return State.Incomplete;
+    for (const [key, symbolList] of symbols) {
+        if (symbolList.some((s, idx) => s === State.Incomplete &&
+            grid.symbols.get(key)[idx].necessaryForCompletion))
+            return State.Incomplete;
+    }
+    if (rules.length === 0 && symbols.size === 0)
+        return State.Incomplete;
+    return State.Satisfied;
+}
+export function applyFinalOverrides(grid, solution, state) {
+    grid.symbols.forEach(list => {
+        list.forEach(sym => {
+            if (handlesFinalValidation(sym)) {
+                state = sym.onFinalValidation(grid, solution, state);
+            }
+        });
+    });
+    grid.rules.forEach(rule => {
+        if (handlesFinalValidation(rule)) {
+            state = rule.onFinalValidation(grid, solution, state);
+        }
+    });
+    return state;
+}
+export default function validateGrid(grid, solution) {
+    let requireSolution = false;
+    // validate all rules with self-contained logic
+    const ruleStates = grid.rules.map(rule => {
+        if (rule.validateWithSolution)
+            requireSolution = true;
+        return rule.validateGrid(grid);
+    });
+    // validate all symbols with symbol overrides
+    const symbolOverrideStates = ruleStates.map(() => []);
+    const applySymbolOverrides = (grid, rules, symbol, validator) => {
+        const [rule, ...rest] = rules;
+        if (rule) {
+            const newValidator = (grid) => applySymbolOverrides(grid, rest, symbol, () => validator(grid));
+            if (!handlesSymbolValidation(rule))
+                return newValidator(grid);
+            const result = rule.onSymbolValidation(grid, symbol, newValidator);
+            if (result === undefined) {
+                return newValidator(grid);
+            }
+            const index = grid.rules.indexOf(rule);
+            symbolOverrideStates[index].push(result);
+            return result;
+        }
+        return validator(grid);
+    };
+    const symbolStates = new Map();
+    grid.symbols.forEach((symbolList, id) => symbolStates.set(id, symbolList.map(s => {
+        if (s.validateWithSolution)
+            requireSolution = true;
+        return applySymbolOverrides(grid, grid.rules, s, g => s.validateSymbol(g));
+    })));
+    // apply the result of symbol overrides to the rules that provided them
+    symbolOverrideStates.forEach((states, i) => {
+        if (ruleStates[i].state !== State.Incomplete)
+            return;
+        if (states.some(s => s === State.Error))
+            ruleStates[i] = { state: State.Error, positions: [] };
+        else if (states.length > 0 && states.every(s => s === State.Satisfied))
+            ruleStates[i] = { state: State.Satisfied };
+    });
+    let final = aggregateState(ruleStates, grid, symbolStates);
+    // in addition to satisfying all rules and symbols, a solution must also fill the grid completely
+    if (!requireSolution && final === State.Satisfied) {
+        final = grid.forEach(tile => tile.exists && tile.color === Color.Gray ? true : undefined)
+            ? State.Incomplete
+            : State.Satisfied;
+    }
+    // return early if there is no need to validate against a solution
+    if (final === State.Satisfied ||
+        !requireSolution ||
+        !solution ||
+        solution.width !== grid.width ||
+        solution.height !== grid.height) {
+        return applyFinalOverrides(grid, solution, {
+            final,
+            rules: ruleStates,
+            symbols: symbolStates,
+        });
+    }
+    // validate against the solution
+    for (let y = 0; y < grid.height; y++) {
+        for (let x = 0; x < grid.width; x++) {
+            if (grid.getTile(x, y).exists &&
+                grid.getTile(x, y).color !== solution.getTile(x, y).color) {
+                return applyFinalOverrides(grid, solution, {
+                    final: State.Incomplete,
+                    rules: ruleStates,
+                    symbols: symbolStates,
+                });
+            }
+        }
+    }
+    // mark all rules and symbols that are satisfied by the solution
+    grid.rules.forEach((rule, i) => {
+        if (rule.validateWithSolution) {
+            ruleStates[i] = { ...ruleStates[i], state: State.Satisfied };
+        }
+    });
+    grid.symbols.forEach((_, id) => {
+        const symbolList = symbolStates.get(id);
+        symbolList.forEach((_, i) => {
+            const symbol = grid.symbols.get(id)[i];
+            if (symbol.validateWithSolution) {
+                symbolList[i] = State.Satisfied;
+            }
+        });
+    });
+    const finalState = {
+        final: State.Satisfied,
+        rules: ruleStates,
+        symbols: symbolStates,
+    };
+    return applyFinalOverrides(grid, solution, finalState);
+}

package/dist/index.d.ts

@@ -0,0 +1,96 @@
+import { ConfigType, configEquals } from '../src/data/config';
+import Configurable from '../src/data/configurable';
+import { allEqual, array, directionToRotation, escape, maxBy, minBy, move, orientationToRotation, resize, unescape } from '../src/data/dataHelper';
+import { isEventHandler } from '../src/data/events/eventHelper';
+import { handlesFinalValidation } from '../src/data/events/onFinalValidation';
+import { handlesGridChange } from '../src/data/events/onGridChange';
+import { handlesGridResize } from '../src/data/events/onGridResize';
+import { handlesSetGrid } from '../src/data/events/onSetGrid';
+import { handlesSymbolValidation } from '../src/data/events/onSymbolValidation';
+import GridData from '../src/data/grid';
+import GridConnections from '../src/data/gridConnections';
+import Instruction from '../src/data/instruction';
+import { COMPARISONS, Color, Comparison, DIRECTIONS, Direction, Mode, ORIENTATIONS, Orientation, State, directionToggle, orientationToggle } from '../src/data/primitives';
+import { MetadataSchema, PuzzleSchema } from '../src/data/puzzle';
+import BanPatternRule from '../src/data/rules/banPatternRule';
+import CellCountRule from '../src/data/rules/cellCountRule';
+import CompletePatternRule from '../src/data/rules/completePatternRule';
+import ConnectAllRule from '../src/data/rules/connectAllRule';
+import CustomRule from '../src/data/rules/customRule';
+import ForesightRule from '../src/data/rules/foresightRule';
+import { allRules } from '../src/data/rules/index';
+import { ControlLine, Row } from '../src/data/rules/musicControlLine';
+import MusicGridRule from '../src/data/rules/musicGridRule';
+import MysteryRule from '../src/data/rules/mysteryRule';
+import OffByXRule from '../src/data/rules/offByXRule';
+import RegionAreaRule from '../src/data/rules/regionAreaRule';
+import RegionShapeRule from '../src/data/rules/regionShapeRule';
+import Rule from '../src/data/rules/rule';
+import SameShapeRule from '../src/data/rules/sameShapeRule';
+import SymbolsPerRegionRule from '../src/data/rules/symbolsPerRegionRule';
+import UndercluedRule from '../src/data/rules/undercluedRule';
+import UniqueShapeRule from '../src/data/rules/uniqueShapeRule';
+import { Serializer } from '../src/data/serializer/allSerializers';
+import { Compressor } from '../src/data/serializer/compressor/allCompressors';
+import CompressorBase from '../src/data/serializer/compressor/compressorBase';
+import DeflateCompressor from '../src/data/serializer/compressor/deflateCompressor';
+import GzipCompressor from '../src/data/serializer/compressor/gzipCompressor';
+import StreamCompressor from '../src/data/serializer/compressor/streamCompressor';
+import SerializerBase from '../src/data/serializer/serializerBase';
+import SerializerV0 from '../src/data/serializer/serializer_v0';
+import { getShapeVariants, normalizeShape, positionsToShape, shapeEquals, tilesToShape } from '../src/data/shapes';
+import { allSolvers } from '../src/data/solver/allSolvers';
+import BacktrackSolver from '../src/data/solver/backtrack/backtrackSolver';
+import BTModule, { BTGridData, BTTile, IntArray2D, colorToBTTile, createOneTileResult, getOppositeColor } from '../src/data/solver/backtrack/data';
+import BanPatternBTModule from '../src/data/solver/backtrack/rules/banPattern';
+import CellCountBTModule from '../src/data/solver/backtrack/rules/cellCount';
+import ConnectAllBTModule from '../src/data/solver/backtrack/rules/connectAll';
+import RegionAreaBTModule from '../src/data/solver/backtrack/rules/regionArea';
+import RegionShapeBTModule from '../src/data/solver/backtrack/rules/regionShape';
+import SameShapeBTModule from '../src/data/solver/backtrack/rules/sameShape';
+import SymbolsPerRegionBTModule from '../src/data/solver/backtrack/rules/symbolsPerRegion';
+import UniqueShapeBTModule from '../src/data/solver/backtrack/rules/uniqueShape';
+import AreaNumberBTModule from '../src/data/solver/backtrack/symbols/areaNumber';
+import DartBTModule from '../src/data/solver/backtrack/symbols/dart';
+import DirectionLinkerBTModule from '../src/data/solver/backtrack/symbols/directionLinker';
+import GalaxyBTModule from '../src/data/solver/backtrack/symbols/galaxy';
+import LetterBTModule from '../src/data/solver/backtrack/symbols/letter';
+import LotusBTModule from '../src/data/solver/backtrack/symbols/lotus';
+import MinesweeperBTModule from '../src/data/solver/backtrack/symbols/minesweeper';
+import MyopiaBTModule from '../src/data/solver/backtrack/symbols/myopia';
+import ViewpointBTModule from '../src/data/solver/backtrack/symbols/viewpoint';
+import Solver from '../src/data/solver/solver';
+import UndercluedSolver from '../src/data/solver/underclued/undercluedSolver';
+import AreaNumberModule from '../src/data/solver/z3/modules/areaNumberModule';
+import CellCountModule from '../src/data/solver/z3/modules/cellCountModule';
+import ConnectAllModule from '../src/data/solver/z3/modules/connectAllModule';
+import DartModule from '../src/data/solver/z3/modules/dartModule';
+import { allZ3Modules } from '../src/data/solver/z3/modules/index';
+import LetterModule from '../src/data/solver/z3/modules/letterModule';
+import MyopiaModule from '../src/data/solver/z3/modules/myopiaModule';
+import RegionAreaModule from '../src/data/solver/z3/modules/regionAreaModule';
+import ViewpointModule from '../src/data/solver/z3/modules/viewpointModule';
+import Z3Module from '../src/data/solver/z3/modules/z3Module';
+import { convertDirection } from '../src/data/solver/z3/utils';
+import Z3Solver from '../src/data/solver/z3/z3Solver';
+import Z3SolverContext from '../src/data/solver/z3/z3SolverContext';
+import AreaNumberSymbol from '../src/data/symbols/areaNumberSymbol';
+import CustomIconSymbol from '../src/data/symbols/customIconSymbol';
+import CustomSymbol from '../src/data/symbols/customSymbol';
+import CustomTextSymbol from '../src/data/symbols/customTextSymbol';
+import DartSymbol from '../src/data/symbols/dartSymbol';
+import DirectionLinkerSymbol from '../src/data/symbols/directionLinkerSymbol';
+import GalaxySymbol from '../src/data/symbols/galaxySymbol';
+import { allSymbols } from '../src/data/symbols/index';
+import LetterSymbol from '../src/data/symbols/letterSymbol';
+import LotusSymbol from '../src/data/symbols/lotusSymbol';
+import MinesweeperSymbol from '../src/data/symbols/minesweeperSymbol';
+import MultiEntrySymbol from '../src/data/symbols/multiEntrySymbol';
+import MyopiaSymbol from '../src/data/symbols/myopiaSymbol';
+import NumberSymbol from '../src/data/symbols/numberSymbol';
+import Symbol from '../src/data/symbols/symbol';
+import ViewpointSymbol from '../src/data/symbols/viewpointSymbol';
+import TileData from '../src/data/tile';
+import TileConnections from '../src/data/tileConnections';
+import validateGrid, { aggregateState, applyFinalOverrides } from '../src/data/validate';
+export { ConfigType, configEquals, Configurable, allEqual, array, directionToRotation, escape, maxBy, minBy, move, orientationToRotation, resize, unescape, isEventHandler, handlesFinalValidation, handlesGridChange, handlesGridResize, handlesSetGrid, handlesSymbolValidation, GridData, GridConnections, Instruction, COMPARISONS, Color, Comparison, DIRECTIONS, Direction, Mode, ORIENTATIONS, Orientation, State, directionToggle, orientationToggle, MetadataSchema, PuzzleSchema, BanPatternRule, CellCountRule, CompletePatternRule, ConnectAllRule, CustomRule, ForesightRule, allRules, ControlLine, Row, MusicGridRule, MysteryRule, OffByXRule, RegionAreaRule, RegionShapeRule, Rule, SameShapeRule, SymbolsPerRegionRule, UndercluedRule, UniqueShapeRule, Serializer, Compressor, CompressorBase, DeflateCompressor, GzipCompressor, StreamCompressor, SerializerBase, SerializerV0, getShapeVariants, normalizeShape, positionsToShape, shapeEquals, tilesToShape, allSolvers, BacktrackSolver, BTModule, BTGridData, BTTile, IntArray2D, colorToBTTile, createOneTileResult, getOppositeColor, BanPatternBTModule, CellCountBTModule, ConnectAllBTModule, RegionAreaBTModule, RegionShapeBTModule, SameShapeBTModule, SymbolsPerRegionBTModule, UniqueShapeBTModule, AreaNumberBTModule, DartBTModule, DirectionLinkerBTModule, GalaxyBTModule, LetterBTModule, LotusBTModule, MinesweeperBTModule, MyopiaBTModule, ViewpointBTModule, Solver, UndercluedSolver, AreaNumberModule, CellCountModule, ConnectAllModule, DartModule, allZ3Modules, LetterModule, MyopiaModule, RegionAreaModule, ViewpointModule, Z3Module, convertDirection, Z3Solver, Z3SolverContext, AreaNumberSymbol, CustomIconSymbol, CustomSymbol, CustomTextSymbol, DartSymbol, DirectionLinkerSymbol, GalaxySymbol, allSymbols, LetterSymbol, LotusSymbol, MinesweeperSymbol, MultiEntrySymbol, MyopiaSymbol, NumberSymbol, Symbol, ViewpointSymbol, TileData, TileConnections, validateGrid, aggregateState, applyFinalOverrides, };