@logic-pad/core 0.26.1 → 0.26.2

package/dist/src/data/symbols/letterSymbol.js

@@ -1,118 +0,0 @@
-import { ConfigType } from '../config.js';
-import GridData from '../grid.js';
-import { array } from '../dataHelper.js';
-import { Color, State } from '../primitives.js';
-import Symbol from './symbol.js';
-export default class LetterSymbol extends Symbol {
-    x;
-    y;
-    letter;
-    title = 'Letter';
-    static CONFIGS = 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.String,
-            default: 'A',
-            field: 'letter',
-            description: 'Letter',
-            explanation: 'Use single uppercase letters by convention.',
-            configurable: true,
-        },
-    ]);
-    static EXAMPLE_GRID = Object.freeze(GridData.create(['bbbww', 'wwbbw', 'wwbbb', 'bwwww'])
-        .addSymbol(new LetterSymbol(0, 0, 'B'))
-        .addSymbol(new LetterSymbol(3, 0, 'A'))
-        .addSymbol(new LetterSymbol(4, 1, 'A'))
-        .addSymbol(new LetterSymbol(3, 2, 'B'))
-        .addSymbol(new LetterSymbol(1, 1, 'C'))
-        .addSymbol(new LetterSymbol(0, 2, 'C'))
-        .addSymbol(new LetterSymbol(4, 3, 'C')));
-    /**
-     * **Letters must be sorted into one type per area**
-     *
-     * @param x - The x-coordinate of the symbol.
-     * @param y - The y-coordinate of the symbol.
-     * @param letter - The letter of the symbol.
-     */
-    constructor(x, y, letter) {
-        super(x, y);
-        this.x = x;
-        this.y = y;
-        this.letter = letter;
-        this.letter = letter;
-    }
-    get id() {
-        return `letter`;
-    }
-    get explanation() {
-        return '*Letters* must be sorted into one type per area';
-    }
-    get configs() {
-        return LetterSymbol.CONFIGS;
-    }
-    createExampleGrid() {
-        return LetterSymbol.EXAMPLE_GRID;
-    }
-    validateSymbol(grid) {
-        if (!this.validateSubtilePlacement(grid))
-            return State.Error;
-        const thisX = Math.floor(this.x);
-        const thisY = Math.floor(this.y);
-        let complete = true;
-        const visited = array(grid.width, grid.height, () => false);
-        const connected = array(grid.width, grid.height, () => false);
-        const color = grid.getTile(thisX, thisY).color;
-        if (color !== Color.Gray) {
-            grid.iterateArea({ x: thisX, y: thisY }, tile => tile.color === Color.Gray || tile.color === color, (tile, x, y) => {
-                visited[y][x] = true;
-                if (tile.color === Color.Gray)
-                    complete = false;
-            });
-            grid.iterateArea({ x: thisX, y: thisY }, tile => tile.color === color, (_, x, y) => {
-                connected[y][x] = true;
-            });
-        }
-        else {
-            complete = false;
-        }
-        for (const symbol of grid.symbols.get(this.id) ?? []) {
-            if (symbol !== this && symbol instanceof LetterSymbol) {
-                const symbolX = Math.floor(symbol.x);
-                const symbolY = Math.floor(symbol.y);
-                if (symbol.letter === this.letter) {
-                    const theirColor = grid.getTile(symbolX, symbolY).color;
-                    if ((color !== Color.Gray && !visited[symbolY][symbolX]) ||
-                        (color !== Color.Gray &&
-                            theirColor !== Color.Gray &&
-                            theirColor !== color)) {
-                        return State.Error;
-                    }
-                }
-                else if (color !== Color.Gray && connected[symbolY][symbolX]) {
-                    return State.Error;
-                }
-            }
-        }
-        return complete ? State.Satisfied : State.Incomplete;
-    }
-    copyWith({ x, y, letter, }) {
-        return new LetterSymbol(x ?? this.x, y ?? this.y, letter ?? this.letter);
-    }
-    withLetter(letter) {
-        return this.copyWith({ letter });
-    }
-}
-export const instance = new LetterSymbol(0, 0, 'A');

package/dist/src/data/symbols/lotusSymbol.d.ts

@@ -1,30 +0,0 @@
-import { AnyConfig } from '../config.js';
-import GridData from '../grid.js';
-import { Orientation, State } from '../primitives.js';
-import DirectionLinkerSymbol from './directionLinkerSymbol.js';
-export default class LotusSymbol extends DirectionLinkerSymbol {
-    readonly x: number;
-    readonly y: number;
-    readonly orientation: Orientation;
-    readonly title = "Lotus";
-    private static readonly linkedDirectionsFromOrientation;
-    /**
-     * **Areas containing this symbol must be symmetrical**
-     *
-     * @param x - The x-coordinate of the symbol.
-     * @param y - The y-coordinate of the symbol.
-     * @param orientation - The orientation of the symbol.
-     */
-    constructor(x: number, y: number, orientation: Orientation);
-    get id(): string;
-    get explanation(): string;
-    get configs(): readonly AnyConfig[] | null;
-    createExampleGrid(): GridData;
-    validateSymbol(grid: GridData): State;
-    copyWith({ x, y, orientation, }: {
-        x?: number;
-        y?: number;
-        orientation?: Orientation;
-    }): this;
-}
-export declare const instance: LotusSymbol;

package/dist/src/data/symbols/lotusSymbol.js

@@ -1,132 +0,0 @@
-import { ConfigType } from '../config.js';
-import GridData from '../grid.js';
-import { Direction, Orientation, State } from '../primitives.js';
-import DirectionLinkerSymbol from './directionLinkerSymbol.js';
-export default class LotusSymbol extends DirectionLinkerSymbol {
-    x;
-    y;
-    orientation;
-    title = 'Lotus';
-    static linkedDirectionsFromOrientation = {
-        [Orientation.Up]: {
-            [Direction.Left]: Direction.Right,
-            [Direction.Up]: Direction.Up,
-            [Direction.Right]: Direction.Left,
-            [Direction.Down]: Direction.Down,
-        },
-        [Orientation.UpRight]: {
-            [Direction.Left]: Direction.Down,
-            [Direction.Up]: Direction.Right,
-            [Direction.Right]: Direction.Up,
-            [Direction.Down]: Direction.Left,
-        },
-        [Orientation.Right]: {
-            [Direction.Left]: Direction.Left,
-            [Direction.Up]: Direction.Down,
-            [Direction.Right]: Direction.Right,
-            [Direction.Down]: Direction.Up,
-        },
-        [Orientation.DownRight]: {
-            [Direction.Left]: Direction.Up,
-            [Direction.Up]: Direction.Left,
-            [Direction.Right]: Direction.Down,
-            [Direction.Down]: Direction.Right,
-        },
-        [Orientation.Down]: {
-            [Direction.Left]: Direction.Right,
-            [Direction.Up]: Direction.Up,
-            [Direction.Right]: Direction.Left,
-            [Direction.Down]: Direction.Down,
-        },
-        [Orientation.DownLeft]: {
-            [Direction.Left]: Direction.Down,
-            [Direction.Up]: Direction.Right,
-            [Direction.Right]: Direction.Up,
-            [Direction.Down]: Direction.Left,
-        },
-        [Orientation.Left]: {
-            [Direction.Left]: Direction.Left,
-            [Direction.Up]: Direction.Down,
-            [Direction.Right]: Direction.Right,
-            [Direction.Down]: Direction.Up,
-        },
-        [Orientation.UpLeft]: {
-            [Direction.Left]: Direction.Up,
-            [Direction.Up]: Direction.Left,
-            [Direction.Right]: Direction.Down,
-            [Direction.Down]: Direction.Right,
-        },
-    };
-    /**
-     * **Areas containing this symbol must be symmetrical**
-     *
-     * @param x - The x-coordinate of the symbol.
-     * @param y - The y-coordinate of the symbol.
-     * @param orientation - The orientation of the symbol.
-     */
-    constructor(x, y, orientation) {
-        super(x, y);
-        this.x = x;
-        this.y = y;
-        this.orientation = orientation;
-        super.changeDirections(LotusSymbol.linkedDirectionsFromOrientation[orientation]);
-    }
-    get id() {
-        return `lotus`;
-    }
-    get explanation() {
-        return `Areas containing this symbol must be *symmetrical*`;
-    }
-    get configs() {
-        return 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.Orientation,
-                default: Orientation.Up,
-                field: 'orientation',
-                description: 'Orientation',
-                configurable: true,
-            },
-        ]);
-    }
-    createExampleGrid() {
-        return Object.freeze(GridData.create(['wwbww', 'bwbwb', 'bwwwb', 'bwwwb']).addSymbol(new LotusSymbol(2, 2, Orientation.Up)));
-    }
-    validateSymbol(grid) {
-        if (this.orientation === Orientation.DownLeft ||
-            this.orientation === Orientation.DownRight ||
-            this.orientation === Orientation.UpLeft ||
-            this.orientation === Orientation.UpRight) {
-            if (this.x % 1 === 0 || this.y % 1 === 0)
-                if (this.x % 1 !== 0 || this.y % 1 !== 0) {
-                    if (!grid.getTile(Math.floor(this.x), Math.floor(this.y)).exists &&
-                        !grid.getTile(Math.ceil(this.x), Math.ceil(this.y)).exists &&
-                        !grid.getTile(Math.floor(this.x), Math.ceil(this.y)).exists &&
-                        !grid.getTile(Math.ceil(this.x), Math.floor(this.y)).exists) {
-                        return State.Satisfied;
-                    }
-                    else {
-                        return State.Error;
-                    }
-                }
-        }
-        return super.validateSymbol(grid);
-    }
-    copyWith({ x, y, orientation, }) {
-        return new LotusSymbol(x ?? this.x, y ?? this.y, orientation ?? this.orientation);
-    }
-}
-export const instance = new LotusSymbol(0, 0, Orientation.Up);

package/dist/src/data/symbols/minesweeperSymbol.d.ts

@@ -1,33 +0,0 @@
-import { AnyConfig } from '../config.js';
-import GridData from '../grid.js';
-import NumberSymbol from './numberSymbol.js';
-export default class MinesweeperSymbol extends NumberSymbol {
-    readonly title = "Minesweeper Number";
-    private static readonly CONFIGS;
-    private static readonly EXAMPLE_GRID;
-    /**
-     * **Minesweeper Numbers count opposite cells in 8 adjacent spaces**
-     *
-     * @param x - The x-coordinate of the symbol.
-     * @param y - The y-coordinate of the symbol.
-     * @param number - The number of cells seen by the symbol.
-     */
-    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: MinesweeperSymbol;

package/dist/src/data/symbols/minesweeperSymbol.js

@@ -1,106 +0,0 @@
-import { ConfigType } from '../config.js';
-import GridData from '../grid.js';
-import { Color } from '../primitives.js';
-import NumberSymbol from './numberSymbol.js';
-export default class MinesweeperSymbol extends NumberSymbol {
-    title = 'Minesweeper Number';
-    static CONFIGS = 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,
-        },
-    ]);
-    static EXAMPLE_GRID = Object.freeze(GridData.create(['wwbww', 'wwbwb', 'wwbwb', 'bwwww'])
-        .addSymbol(new MinesweeperSymbol(1, 1, 3))
-        .addSymbol(new MinesweeperSymbol(3, 1, 5))
-        .addSymbol(new MinesweeperSymbol(4, 1, 4))
-        .addSymbol(new MinesweeperSymbol(2, 3, 1)));
-    /**
-     * **Minesweeper Numbers count opposite cells in 8 adjacent spaces**
-     *
-     * @param x - The x-coordinate of the symbol.
-     * @param y - The y-coordinate of the symbol.
-     * @param number - The number of cells seen by the symbol.
-     */
-    constructor(x, y, number) {
-        super(x, y, number);
-    }
-    get id() {
-        return `minesweeper`;
-    }
-    get placementStep() {
-        return 1;
-    }
-    get explanation() {
-        return `*Minesweeper Numbers* count opposite cells in 8 adjacent spaces`;
-    }
-    get configs() {
-        return MinesweeperSymbol.CONFIGS;
-    }
-    createExampleGrid() {
-        return MinesweeperSymbol.EXAMPLE_GRID;
-    }
-    countForColor(grid, color) {
-        let gray = 0;
-        let opposite = 0;
-        const visited = [];
-        for (let y = this.y - 1; y <= this.y + 1; y++) {
-            for (let x = this.x - 1; x <= this.x + 1; x++) {
-                if (x === this.x && y === this.y)
-                    continue;
-                if (grid.wrapAround.value) {
-                    const pos = grid.toArrayCoordinates(x, y);
-                    if (visited.some(v => v.x === pos.x && v.y === pos.y))
-                        continue;
-                    visited.push(pos);
-                }
-                const tile = grid.getTile(x, y);
-                if (!tile.exists)
-                    continue;
-                if (tile.color === Color.Gray)
-                    gray++;
-                else if (tile.color !== color)
-                    opposite++;
-            }
-        }
-        return { completed: opposite, possible: opposite + gray };
-    }
-    countTiles(grid) {
-        if (Math.floor(this.x) !== this.x || Math.floor(this.y) !== this.y)
-            return { completed: 0, possible: Number.MAX_SAFE_INTEGER };
-        const color = grid.getTile(this.x, this.y).color;
-        if (color === Color.Gray) {
-            const dark = this.countForColor(grid, Color.Dark);
-            const light = this.countForColor(grid, Color.Light);
-            return {
-                completed: Math.min(dark.completed, light.completed),
-                possible: Math.max(dark.possible, light.possible),
-            };
-        }
-        return this.countForColor(grid, color);
-    }
-    copyWith({ x, y, number, }) {
-        return new MinesweeperSymbol(x ?? this.x, y ?? this.y, number ?? this.number);
-    }
-    withNumber(number) {
-        return this.copyWith({ number });
-    }
-}
-export const instance = new MinesweeperSymbol(0, 0, 1);

package/dist/src/data/symbols/myopiaSymbol.d.ts

@@ -1,37 +0,0 @@
-import { AnyConfig } from '../config.js';
-import { SymbolMergeHandler } from '../events/onSymbolMerge.js';
-import GridData from '../grid.js';
-import { OrientationToggle, State } from '../primitives.js';
-import Symbol from './symbol.js';
-export default class MyopiaSymbol extends Symbol implements SymbolMergeHandler {
-    readonly diagonals: boolean;
-    readonly directions: OrientationToggle;
-    get title(): "Framed Myopia Arrow" | "Myopia Arrow";
-    private static readonly CONFIGS;
-    private static readonly EXAMPLE_GRID;
-    private static readonly EXAMPLE_DIAGONAL_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 diagonals - Whether the symbol should consider diagonal directions.
-     * @param directions - The directions in which an arrow is pointing.
-     */
-    constructor(x: number, y: number, diagonals: boolean, directions: OrientationToggle);
-    get id(): string;
-    get placementStep(): number;
-    get explanation(): string;
-    get configs(): readonly AnyConfig[] | null;
-    createExampleGrid(): GridData;
-    validateSymbol(grid: GridData): State;
-    descriptionEquals(other: Symbol): boolean;
-    copyWith({ x, y, diagonals, directions, }: {
-        x?: number;
-        y?: number;
-        diagonals?: boolean;
-        directions?: OrientationToggle;
-    }): this;
-    withDirections(directions: OrientationToggle): this;
-    withDiagonals(diagonals: boolean): this;
-}
-export declare const instance: MyopiaSymbol;

package/dist/src/data/symbols/myopiaSymbol.js

@@ -1,182 +0,0 @@
-import { ConfigType } from '../config.js';
-import { move } from '../dataHelper.js';
-import GridData from '../grid.js';
-import { Color, ORIENTATIONS, Orientation, State, orientationToggle, } from '../primitives.js';
-import Symbol from './symbol.js';
-export default class MyopiaSymbol extends Symbol {
-    diagonals;
-    directions;
-    get title() {
-        return this.diagonals ? 'Framed Myopia Arrow' : 'Myopia Arrow';
-    }
-    static CONFIGS = 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.Boolean,
-            default: false,
-            field: 'diagonals',
-            description: 'Include diagonal directions',
-            explanation: 'Whether to check diagonals as well. Must be enabled for diagonal arrows.',
-            configurable: true,
-        },
-        {
-            type: ConfigType.OrientationToggle,
-            default: orientationToggle(Orientation.Up, Orientation.Right),
-            field: 'directions',
-            description: 'Directions',
-            explanation: 'The directions in which an arrow is pointing. A dot will be displayed if no arrows are present.',
-            configurable: true,
-        },
-    ]);
-    static EXAMPLE_GRID = Object.freeze(GridData.create(['wbwww', 'bwwwb', 'wwwww', 'wbwww']).withSymbols([
-        new MyopiaSymbol(1, 1, false, orientationToggle(Orientation.Up, Orientation.Left)),
-        new MyopiaSymbol(4, 3, false, orientationToggle(Orientation.Up)),
-    ]));
-    static EXAMPLE_DIAGONAL_GRID = Object.freeze(GridData.create(['wbwww', 'bwwwb', 'wwwww', 'wbwww']).withSymbols([
-        new MyopiaSymbol(1, 2, true, orientationToggle(Orientation.UpLeft, Orientation.Down)),
-        new MyopiaSymbol(3, 2, true, orientationToggle(Orientation.UpRight)),
-    ]));
-    /**
-     * **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 diagonals - Whether the symbol should consider diagonal directions.
-     * @param directions - The directions in which an arrow is pointing.
-     */
-    constructor(x, y, diagonals, directions) {
-        super(x, y);
-        this.diagonals = diagonals;
-        this.directions = directions;
-        this.directions = directions;
-        this.diagonals =
-            directions[Orientation.DownLeft] ||
-                directions[Orientation.DownRight] ||
-                directions[Orientation.UpLeft] ||
-                directions[Orientation.UpRight]
-                ? true
-                : diagonals;
-    }
-    get id() {
-        return `myopia`;
-    }
-    get placementStep() {
-        return 1;
-    }
-    get explanation() {
-        return this.diagonals
-            ? '*Framed myopia arrows* point to *all* the closest opposite cells in 8 directions'
-            : '*Myopia arrows* point to *all* the closest cells of the opposite color';
-    }
-    get configs() {
-        return MyopiaSymbol.CONFIGS;
-    }
-    createExampleGrid() {
-        return this.diagonals
-            ? MyopiaSymbol.EXAMPLE_DIAGONAL_GRID
-            : MyopiaSymbol.EXAMPLE_GRID;
-    }
-    validateSymbol(grid) {
-        const tile = grid.getTile(this.x, this.y);
-        if (!tile.exists || tile.color === Color.Gray)
-            return State.Incomplete;
-        const allDirections = this.diagonals
-            ? ORIENTATIONS
-            : [Orientation.Up, Orientation.Down, Orientation.Left, Orientation.Right];
-        const map = {
-            up: { min: 0, max: 0, complete: true },
-            down: { min: 0, max: 0, complete: true },
-            left: { min: 0, max: 0, complete: true },
-            right: { min: 0, max: 0, complete: true },
-            'up-left': { min: 0, max: 0, complete: true },
-            'up-right': { min: 0, max: 0, complete: true },
-            'down-left': { min: 0, max: 0, complete: true },
-            'down-right': { min: 0, max: 0, complete: true },
-        };
-        const pos = { x: this.x, y: this.y };
-        allDirections.forEach(direction => {
-            let stopped = false;
-            grid.iterateDirectionAll(move(pos, direction), direction, t => {
-                if (!t.exists)
-                    return true;
-                if (t.color === tile.color)
-                    return true;
-                stopped = true;
-                return false;
-            }, () => {
-                map[direction].min++;
-            });
-            if (!stopped && map[direction].min === 0)
-                map[direction].min = Number.MAX_SAFE_INTEGER;
-            stopped = false;
-            grid.iterateDirectionAll(move(pos, direction), direction, t => {
-                if (!t.exists)
-                    return true;
-                if (t.color === tile.color || t.color === Color.Gray)
-                    return true;
-                stopped = true;
-                return false;
-            }, t => {
-                map[direction].max++;
-                if (t.exists && t.color === Color.Gray)
-                    map[direction].complete = false;
-            });
-            if (!stopped)
-                map[direction].max = Number.MAX_SAFE_INTEGER;
-        });
-        const pointedDirections = allDirections.filter(d => this.directions[d]);
-        const otherDirections = allDirections.filter(d => !this.directions[d]);
-        for (let i = 0; i < pointedDirections.length; i++) {
-            const direction1 = pointedDirections[i];
-            for (let j = i + 1; j < pointedDirections.length; j++) {
-                const direction2 = pointedDirections[j];
-                if (map[direction1].min > map[direction2].max)
-                    return State.Error;
-                if (map[direction2].min > map[direction1].max)
-                    return State.Error;
-            }
-        }
-        if (Math.min(...otherDirections.map(d => map[d].max)) <=
-            Math.max(...pointedDirections.map(d => map[d].min)))
-            return State.Error;
-        if (pointedDirections.length === 0 &&
-            otherDirections.some(d => map[d].max !== Number.MAX_SAFE_INTEGER))
-            return State.Error;
-        if (pointedDirections.some(d => map[d].complete && map[d].max === Number.MAX_SAFE_INTEGER))
-            return State.Error;
-        if (pointedDirections.length > 0 &&
-            otherDirections.length > 0 &&
-            pointedDirections.every(d => map[d].complete) &&
-            Math.max(...pointedDirections.map(d => map[d].max)) <
-                Math.min(...otherDirections.map(d => map[d].min)))
-            return State.Satisfied;
-        if (allDirections.every(d => map[d].complete))
-            return State.Satisfied;
-        return State.Incomplete;
-    }
-    descriptionEquals(other) {
-        return this.id === other.id && this.explanation === other.explanation;
-    }
-    copyWith({ x, y, diagonals, directions, }) {
-        return new MyopiaSymbol(x ?? this.x, y ?? this.y, diagonals ?? this.diagonals, directions ?? this.directions);
-    }
-    withDirections(directions) {
-        return this.copyWith({ directions });
-    }
-    withDiagonals(diagonals) {
-        return this.copyWith({ diagonals });
-    }
-}
-export const instance = new MyopiaSymbol(0, 0, false, orientationToggle(Orientation.Up, Orientation.Right));

package/dist/src/data/symbols/numberSymbol.d.ts

@@ -1,19 +0,0 @@
-import GridData from '../grid.js';
-import { State } from '../primitives.js';
-import Symbol from './symbol.js';
-/**
- * All symbols which contain a number should extend this class to be compatible with off by X rules.
- */
-export default abstract class NumberSymbol extends Symbol {
-    readonly x: number;
-    readonly y: number;
-    readonly number: number;
-    constructor(x: number, y: number, number: number);
-    abstract countTiles(grid: GridData): {
-        completed: number;
-        possible: number;
-    } | null;
-    validateSymbol(grid: GridData): State;
-    withNumber(number: number): this;
-}
-export declare const instance: undefined;