@logic-pad/core 0.26.0 → 0.26.2

package/dist/src/data/rules/offByXRule.js

@@ -1,124 +0,0 @@
-import { ConfigType } from '../config.js';
-import GridData from '../grid.js';
-import { Color, State } from '../primitives.js';
-import AreaNumberSymbol from '../symbols/areaNumberSymbol.js';
-import NumberSymbol from '../symbols/numberSymbol.js';
-import Rule from './rule.js';
-export default class OffByXRule extends Rule {
-    number;
-    title = 'Off By X';
-    static CONFIGS = Object.freeze([
-        {
-            type: ConfigType.Number,
-            default: 1,
-            min: 1,
-            field: 'number',
-            description: 'Number',
-            configurable: true,
-        },
-    ]);
-    static EXAMPLE_GRID = Object.freeze([
-        GridData.create(['bbbbb', 'bwbwb', 'bbwwb', 'bbbbb']).withSymbols([
-            new AreaNumberSymbol(1, 1, 2),
-            new AreaNumberSymbol(3, 2, 2),
-        ]),
-        GridData.create(['bbbbb', 'bwbwb', 'bbbwb', 'bwwwb']).withSymbols([
-            new AreaNumberSymbol(1, 1, 3),
-            new AreaNumberSymbol(3, 3, 3),
-        ]),
-        GridData.create(['bbbbw', 'bwbbw', 'bbbbw', 'bwwww']).withSymbols([
-            new AreaNumberSymbol(1, 1, 4),
-            new AreaNumberSymbol(4, 3, 4),
-        ]),
-        GridData.create(['bbbbw', 'bwbbw', 'bbbww', 'wwwww']).withSymbols([
-            new AreaNumberSymbol(1, 1, 5),
-            new AreaNumberSymbol(4, 3, 5),
-        ]),
-        GridData.create(['bbbww', 'bwbww', 'bbbww', 'wwwww']).withSymbols([
-            new AreaNumberSymbol(1, 1, 6),
-            new AreaNumberSymbol(4, 3, 6),
-        ]),
-        GridData.create(['wbbww', 'bbwww', 'bbwww', 'wwwww']).withSymbols([
-            new AreaNumberSymbol(0, 0, 7),
-            new AreaNumberSymbol(4, 3, 7),
-        ]),
-        GridData.create(['wbbww', 'bwwww', 'bwwww', 'wwwww']).withSymbols([
-            new AreaNumberSymbol(0, 0, 8),
-            new AreaNumberSymbol(4, 3, 8),
-        ]),
-        GridData.create(['wbwww', 'bwwww', 'wwwww', 'wwwww']).withSymbols([
-            new AreaNumberSymbol(0, 0, 9),
-            new AreaNumberSymbol(4, 3, 9),
-        ]),
-    ]);
-    static SEARCH_VARIANTS = [new OffByXRule(1).searchVariant()];
-    /**
-     * **All numbers are off by <number>**
-     *
-     * @param number - The number that all cells are off by.
-     */
-    constructor(number) {
-        super();
-        this.number = number;
-        this.number = number;
-    }
-    get id() {
-        return `off_by_x`;
-    }
-    get explanation() {
-        return `All numbers are off by ${this.number}`;
-    }
-    get configs() {
-        return OffByXRule.CONFIGS;
-    }
-    createExampleGrid() {
-        if (this.number < 1 || this.number >= OffByXRule.EXAMPLE_GRID.length) {
-            return GridData.create(['bbbbb', 'bbwbb', 'bbbbb', 'bbbbb']).addSymbol(new AreaNumberSymbol(2, 1, this.number + 1));
-        }
-        return OffByXRule.EXAMPLE_GRID[this.number - 1];
-    }
-    get searchVariants() {
-        return OffByXRule.SEARCH_VARIANTS;
-    }
-    validateGrid(grid) {
-        return {
-            state: grid.getTileCount(true, false, Color.Gray) === 0
-                ? State.Satisfied
-                : State.Incomplete,
-        };
-    }
-    onSymbolValidation(grid, symbol, _validator) {
-        if (symbol instanceof NumberSymbol) {
-            const counts = symbol.countTiles(grid);
-            if (counts === null)
-                return State.Error;
-            if (counts.completed > symbol.number + this.number ||
-                counts.possible < symbol.number - this.number ||
-                (counts.completed > symbol.number - this.number &&
-                    counts.possible < symbol.number + this.number)) {
-                return State.Error;
-            }
-            else if ((counts.completed === symbol.number + this.number ||
-                counts.completed === symbol.number - this.number) &&
-                counts.completed === counts.possible) {
-                return State.Satisfied;
-            }
-            else {
-                return State.Incomplete;
-            }
-        }
-        else {
-            return undefined;
-        }
-    }
-    get isSingleton() {
-        return true;
-    }
-    copyWith({ number }) {
-        return new OffByXRule(number ?? this.number);
-    }
-    withNumber(number) {
-        return this.copyWith({ number });
-    }
-}
-export const instance = new OffByXRule(1);

package/dist/src/data/rules/perfectionRule.d.ts

@@ -1,45 +0,0 @@
-import { AnyConfig } from '../config.js';
-import GridData from '../grid.js';
-import { GridState, RuleState, Mode } from '../primitives.js';
-import Rule, { SearchVariant } from './rule.js';
-import { SetGridHandler } from '../events/onSetGrid.js';
-import { FinalValidationHandler } from '../events/onFinalValidation.js';
-export default class PerfectionRule extends Rule implements SetGridHandler, FinalValidationHandler {
-    readonly editor: boolean;
-    readonly title = "Perfection";
-    get configExplanation(): string;
-    private static readonly EXAMPLE_GRID;
-    private static readonly SEARCH_VARIANTS;
-    /**
-     * **Quest for Perfection: cell colors are final**
-     *
-     * @param editor - whether to enable editor mode. This field is automatically set by the editor.
-     */
-    constructor(editor?: boolean);
-    get id(): string;
-    get explanation(): string;
-    get configs(): readonly AnyConfig[] | null;
-    createExampleGrid(): GridData;
-    get searchVariants(): SearchVariant[];
-    get necessaryForCompletion(): boolean;
-    get isSingleton(): boolean;
-    modeVariant(mode: Mode): Rule | null;
-    validateGrid(grid: GridData): RuleState;
-    /**
-     * If the grid passes validation but is different from the solution, indicate the error in the final state.
-     */
-    onFinalValidation(grid: GridData, solution: GridData | null, state: GridState): GridState;
-    private fixTiles;
-    private isValid;
-    private findSingleError;
-    /**
-     * Force all tiles to be fixed.
-     *
-     * If the grid is already wrong, prevent the player from changing it further.
-     */
-    onSetGrid(oldGrid: GridData, newGrid: GridData, solution: GridData | null): GridData;
-    copyWith({ editor }: {
-        editor?: boolean;
-    }): this;
-}
-export declare const instance: PerfectionRule;

package/dist/src/data/rules/perfectionRule.js

@@ -1,158 +0,0 @@
-import GridData from '../grid.js';
-import { Color, State, Mode, } from '../primitives.js';
-import Rule from './rule.js';
-import CustomIconSymbol from '../symbols/customIconSymbol.js';
-import validateGrid from '../validate.js';
-export default class PerfectionRule extends Rule {
-    editor;
-    title = 'Perfection';
-    get configExplanation() {
-        return 'You should allow players to enable perfection mode themselves instead of enforcing this rule.';
-    }
-    static EXAMPLE_GRID = Object.freeze(GridData.create(['w']).addSymbol(new CustomIconSymbol('', GridData.create(['w']), 0, 0, 'MdStars')));
-    static SEARCH_VARIANTS = [
-        new PerfectionRule().searchVariant(),
-    ];
-    /**
-     * **Quest for Perfection: cell colors are final**
-     *
-     * @param editor - whether to enable editor mode. This field is automatically set by the editor.
-     */
-    constructor(editor = false) {
-        super();
-        this.editor = editor;
-        this.editor = editor;
-    }
-    get id() {
-        return `perfection`;
-    }
-    get explanation() {
-        return `*Quest for Perfection*: cell colors are final`;
-    }
-    get configs() {
-        return null;
-    }
-    createExampleGrid() {
-        return PerfectionRule.EXAMPLE_GRID;
-    }
-    get searchVariants() {
-        return PerfectionRule.SEARCH_VARIANTS;
-    }
-    get necessaryForCompletion() {
-        return false;
-    }
-    get isSingleton() {
-        return true;
-    }
-    modeVariant(mode) {
-        // only allow this rule in perfection mode
-        if (this.editor === (mode === Mode.Create)) {
-            return this;
-        }
-        else if (mode === Mode.Create) {
-            return this.copyWith({ editor: true });
-        }
-        else {
-            return this.copyWith({ editor: false });
-        }
-    }
-    validateGrid(grid) {
-        if (grid.getTileCount(true, undefined, Color.Gray) > 0) {
-            return { state: State.Incomplete };
-        }
-        else {
-            return { state: State.Satisfied };
-        }
-    }
-    /**
-     * If the grid passes validation but is different from the solution, indicate the error in the final state.
-     */
-    onFinalValidation(grid, solution, state) {
-        if (state.final === State.Error)
-            return state;
-        if (solution === null)
-            return state;
-        const positions = [];
-        grid.tiles.forEach((row, y) => row.forEach((t, x) => {
-            if (t.exists &&
-                t.color !== Color.Gray &&
-                t.color !== solution.getTile(x, y).color) {
-                positions.push({ x, y });
-            }
-        }));
-        if (positions.length > 0) {
-            const ruleId = grid.rules.indexOf(this);
-            return {
-                final: State.Error,
-                rules: state.rules.map((r, idx) => {
-                    if (idx === ruleId) {
-                        return { state: State.Error, positions };
-                    }
-                    else {
-                        return r;
-                    }
-                }),
-                symbols: state.symbols,
-            };
-        }
-        return state;
-    }
-    fixTiles(grid, exclusions) {
-        if (grid.getTileCount(true, false, Color.Light) > 0 ||
-            grid.getTileCount(true, false, Color.Dark) > 0) {
-            return grid.withTiles(tiles => tiles.map((row, y) => row.map((t, x) => t.exists &&
-                t.color !== Color.Gray &&
-                !exclusions?.some(e => e.x === x && e.y === y)
-                ? t.withFixed(true)
-                : t)));
-        }
-        return grid;
-    }
-    isValid(grid, solution) {
-        return validateGrid(grid, solution).final !== State.Error;
-    }
-    findSingleError(grid, solution) {
-        if (solution === null)
-            return [];
-        const positions = [];
-        // If a solution is available, we can compare against the solution and allow the user to modify the one single error.
-        grid.tiles.forEach((row, y) => row.forEach((t, x) => {
-            if (t.exists &&
-                t.color !== Color.Gray &&
-                t.color !== solution.getTile(x, y).color) {
-                positions.push({ x, y });
-            }
-        }));
-        if (positions.length > 1) {
-            const connected = grid.connections.getConnectedTiles(positions[0]);
-            if (!positions.every(p => connected.some(c => c.x === p.x && c.y === p.y))) {
-                return [];
-            }
-        }
-        return positions;
-    }
-    /**
-     * Force all tiles to be fixed.
-     *
-     * If the grid is already wrong, prevent the player from changing it further.
-     */
-    onSetGrid(oldGrid, newGrid, solution) {
-        if (this.editor)
-            return newGrid;
-        const oldGridIsValid = this.isValid(oldGrid, solution);
-        const newGridIsValid = this.isValid(newGrid, solution);
-        if (!oldGridIsValid && !newGridIsValid) {
-            const oldPositions = this.findSingleError(oldGrid, solution);
-            return this.fixTiles(oldGrid, oldPositions);
-        }
-        else if (!newGridIsValid) {
-            const positions = this.findSingleError(newGrid, solution);
-            return this.fixTiles(newGrid, positions);
-        }
-        return this.fixTiles(newGrid);
-    }
-    copyWith({ editor }) {
-        return new PerfectionRule(editor ?? this.editor);
-    }
-}
-export const instance = new PerfectionRule();

package/dist/src/data/rules/regionAreaRule.d.ts

@@ -1,34 +0,0 @@
-import { AnyConfig } from '../config.js';
-import GridData from '../grid.js';
-import { Color, RuleState } from '../primitives.js';
-import Rule, { SearchVariant } from './rule.js';
-export default class RegionAreaRule extends Rule {
-    readonly color: Color;
-    readonly size: number;
-    readonly title = "Region Area Size";
-    private static readonly CONFIGS;
-    private static readonly EXAMPLE_GRID_DARK;
-    private static readonly EXAMPLE_GRID_LIGHT;
-    private static readonly EXAMPLE_GRID_GRAY;
-    private static readonly SEARCH_VARIANTS;
-    /**
-     * **All <color> regions have area <size>**
-     *
-     * @param color - The color of the regions.
-     * @param size - The area of the regions.
-     */
-    constructor(color: Color, size: number);
-    get id(): string;
-    get explanation(): string;
-    get configs(): readonly AnyConfig[] | null;
-    createExampleGrid(): GridData;
-    get searchVariants(): SearchVariant[];
-    validateGrid(grid: GridData): RuleState;
-    copyWith({ color, size }: {
-        color?: Color;
-        size?: number;
-    }): this;
-    withColor(color: Color): this;
-    withSize(size: number): this;
-}
-export declare const instance: RegionAreaRule;

package/dist/src/data/rules/regionAreaRule.js

@@ -1,149 +0,0 @@
-import { ConfigType } from '../config.js';
-import GridData from '../grid.js';
-import { array } from '../dataHelper.js';
-import { Color, State } from '../primitives.js';
-import TileData from '../tile.js';
-import Rule from './rule.js';
-export default class RegionAreaRule extends Rule {
-    color;
-    size;
-    title = 'Region Area Size';
-    static CONFIGS = Object.freeze([
-        {
-            type: ConfigType.Color,
-            default: Color.Dark,
-            allowGray: false,
-            field: 'color',
-            description: 'Color',
-            configurable: true,
-        },
-        {
-            type: ConfigType.Number,
-            default: 2,
-            min: 0,
-            field: 'size',
-            description: 'Region Size',
-            configurable: true,
-        },
-    ]);
-    static EXAMPLE_GRID_DARK = Object.freeze([
-        GridData.create(['wwwww', 'wwwww', 'wwwww', 'wwwww']),
-        GridData.create(['bwwbw', 'wbwwb', 'bwbww', 'wbwwb']),
-        GridData.create(['bbwbb', 'wwbww', 'wwbww', 'wwwbb']),
-        GridData.create(['bbwww', 'bwbwb', 'wbbwb', 'wwwwb']),
-        GridData.create(['bwbbb', 'bbwwb', 'bwbbw', 'wwbbw']),
-        GridData.create(['bbbww', 'bbwbw', 'wwbbb', 'wwwbw']),
-        GridData.create(['bbbww', 'bbbwb', 'wwwbb', 'wwbbb']),
-        GridData.create(['bbbbb', 'bbwww', 'wwwbb', 'bbbbb']),
-        GridData.create(['bbbbw', 'bbbww', 'bwwww', 'wwwww']),
-        GridData.create(['wwwww', 'bbbbb', 'bbwbb', 'wwwww']),
-        GridData.create(['bbbbb', 'bbbww', 'bbwww', 'wwwww']),
-    ]);
-    static EXAMPLE_GRID_LIGHT = Object.freeze(RegionAreaRule.EXAMPLE_GRID_DARK.map(grid => GridData.create(grid.width, grid.height, grid.tiles.map(row => row.map(tile => tile.withColor(tile.color === Color.Dark ? Color.Light : Color.Dark))))));
-    static EXAMPLE_GRID_GRAY = Object.freeze(RegionAreaRule.EXAMPLE_GRID_DARK.map(grid => GridData.create(grid.width, grid.height, grid.tiles.map((row, y) => row.map((tile, x) => tile.withColor(tile.color === Color.Dark
-        ? Color.Gray
-        : x % 2 !== y % 2
-            ? Color.Dark
-            : Color.Light))))));
-    static SEARCH_VARIANTS = [
-        new RegionAreaRule(Color.Dark, 2).searchVariant(),
-        new RegionAreaRule(Color.Light, 2).searchVariant(),
-    ];
-    /**
-     * **All <color> regions have area <size>**
-     *
-     * @param color - The color of the regions.
-     * @param size - The area of the regions.
-     */
-    constructor(color, size) {
-        super();
-        this.color = color;
-        this.size = size;
-        this.color = color;
-        this.size = size;
-    }
-    get id() {
-        return `region_area`;
-    }
-    get explanation() {
-        return `All ${this.color} regions have area ${this.size}`;
-    }
-    get configs() {
-        return RegionAreaRule.CONFIGS;
-    }
-    createExampleGrid() {
-        if (this.size < RegionAreaRule.EXAMPLE_GRID_DARK.length) {
-            switch (this.color) {
-                case Color.Dark:
-                    return RegionAreaRule.EXAMPLE_GRID_DARK[this.size];
-                case Color.Light:
-                    return RegionAreaRule.EXAMPLE_GRID_LIGHT[this.size];
-                case Color.Gray:
-                    return RegionAreaRule.EXAMPLE_GRID_GRAY[this.size];
-            }
-        }
-        else {
-            let count = this.size;
-            const tiles = array(5, 4, (x, y) => {
-                count--;
-                return new TileData(true, false, count >= 0
-                    ? this.color
-                    : this.color === Color.Gray
-                        ? x % 2 !== y % 2
-                            ? Color.Dark
-                            : Color.Light
-                        : this.color === Color.Light
-                            ? Color.Dark
-                            : Color.Light);
-            });
-            return GridData.create(5, 4, tiles);
-        }
-    }
-    get searchVariants() {
-        return RegionAreaRule.SEARCH_VARIANTS;
-    }
-    validateGrid(grid) {
-        const visited = array(grid.width, grid.height, (i, j) => !(grid.getTile(i, j).exists && grid.getTile(i, j).color === this.color));
-        let complete = true;
-        while (true) {
-            const seed = grid.find((_tile, x, y) => !visited[y][x]);
-            if (!seed)
-                break;
-            const completed = [];
-            const gray = [];
-            grid.iterateArea({ x: seed.x, y: seed.y }, tile => tile.color === this.color, (_, x, y) => {
-                completed.push({ x, y });
-                visited[y][x] = true;
-            });
-            if (this.color === Color.Gray) {
-                gray.push(...completed);
-            }
-            else {
-                grid.iterateArea({ x: seed.x, y: seed.y }, tile => tile.color === Color.Gray || tile.color === this.color, (_, x, y) => {
-                    gray.push({ x, y });
-                });
-            }
-            if (completed.length > this.size) {
-                return { state: State.Error, positions: completed };
-            }
-            else if (gray.length < this.size) {
-                return { state: State.Error, positions: gray };
-            }
-            else if (completed.length !== this.size ||
-                completed.length !== gray.length) {
-                complete = false;
-            }
-        }
-        return complete ? { state: State.Satisfied } : { state: State.Incomplete };
-    }
-    copyWith({ color, size }) {
-        return new RegionAreaRule(color ?? this.color, size ?? this.size);
-    }
-    withColor(color) {
-        return this.copyWith({ color });
-    }
-    withSize(size) {
-        return this.copyWith({ size });
-    }
-}
-export const instance = new RegionAreaRule(Color.Dark, 2);

package/dist/src/data/rules/regionShapeRule.d.ts

@@ -1,22 +0,0 @@
-import GridData from '../grid.js';
-import { Color, Position } from '../primitives.js';
-import { Shape } from '../shapes.js';
-import Rule from './rule.js';
-export type ShapeRegions = {
-    regions: {
-        positions: Position[];
-        shape: Shape;
-        count: number;
-    }[];
-    complete: boolean;
-};
-export default abstract class RegionShapeRule extends Rule {
-    readonly color: Color;
-    /**
-     * @param color - The color of the regions to compare.
-     */
-    constructor(color: Color);
-    protected getShapeRegions(grid: GridData): ShapeRegions;
-    withColor(color: Color): this;
-}
-export declare const instance: undefined;

package/dist/src/data/rules/regionShapeRule.js

@@ -1,58 +0,0 @@
-import { array } from '../dataHelper.js';
-import { Color } from '../primitives.js';
-import { normalizeShape, positionsToShape, shapeEquals, } from '../shapes.js';
-import Rule from './rule.js';
-export default class RegionShapeRule extends Rule {
-    color;
-    /**
-     * @param color - The color of the regions to compare.
-     */
-    constructor(color) {
-        super();
-        this.color = color;
-        this.color = color;
-    }
-    getShapeRegions(grid) {
-        let complete = true;
-        const visited = array(grid.width, grid.height, (i, j) => {
-            const tile = grid.getTile(i, j);
-            if (tile.exists && tile.color === Color.Gray)
-                complete = false;
-            return !(tile.exists && tile.color === this.color);
-        });
-        const regions = [];
-        while (true) {
-            const seed = grid.find((_tile, x, y) => !visited[y][x]);
-            if (!seed)
-                break;
-            const positions = [];
-            grid.iterateArea(seed, tile => tile.color === this.color, (_, x, y, logX, logY) => {
-                visited[y][x] = true;
-                positions.push({ x: logX, y: logY });
-            });
-            const incomplete = grid.iterateArea(seed, tile => tile.color === this.color || tile.color === Color.Gray, tile => {
-                if (tile.color === Color.Gray)
-                    return true;
-            });
-            if (incomplete)
-                continue;
-            const shape = normalizeShape(positionsToShape(positions, this.color));
-            const existing = regions.find(island => shapeEquals(island.shape, shape));
-            if (existing) {
-                existing.count++;
-            }
-            else {
-                regions.push({
-                    positions: positions.map(pos => grid.toArrayCoordinates(pos.x, pos.y)),
-                    shape,
-                    count: 1,
-                });
-            }
-        }
-        return { regions, complete };
-    }
-    withColor(color) {
-        return this.copyWith({ color });
-    }
-}
-export const instance = undefined;

package/dist/src/data/rules/rule.d.ts

@@ -1,18 +0,0 @@
-import GridData from '../grid.js';
-import { Mode, RuleState } from '../primitives.js';
-import Instruction from '../instruction.js';
-export interface SearchVariant {
-    description: string;
-    rule: Rule;
-}
-export default abstract class Rule extends Instruction {
-    abstract validateGrid(grid: GridData): RuleState;
-    abstract get searchVariants(): SearchVariant[];
-    searchVariant(): SearchVariant;
-    modeVariant(_mode: Mode): Rule | null;
-    /**
-     * Whether only one instance of this rule is allowed in a grid.
-     */
-    get isSingleton(): boolean;
-}
-export declare const instance: undefined;

package/dist/src/data/rules/rule.js

@@ -1,19 +0,0 @@
-import Instruction from '../instruction.js';
-export default class Rule extends Instruction {
-    searchVariant() {
-        return {
-            description: this.explanation,
-            rule: this,
-        };
-    }
-    modeVariant(_mode) {
-        return this;
-    }
-    /**
-     * Whether only one instance of this rule is allowed in a grid.
-     */
-    get isSingleton() {
-        return false;
-    }
-}
-export const instance = undefined;

package/dist/src/data/rules/rules.gen.d.ts

@@ -1,23 +0,0 @@
-export { instance as BanPatternRule } from './banPatternRule.js';
-export { instance as CellCountRule } from './cellCountRule.js';
-export { instance as CompletePatternRule } from './completePatternRule.js';
-export { instance as ConnectAllRule } from './connectAllRule.js';
-export { instance as ConnectZonesRule } from './connectZonesRule.js';
-export { instance as ContainsShapeRule } from './containsShapeRule.js';
-export { instance as CustomRule } from './customRule.js';
-export { instance as DifferentCountPerZoneRule } from './differentCountPerZoneRule.js';
-export { instance as ExactCountPerZoneRule } from './exactCountPerZoneRule.js';
-export { instance as ForesightRule } from './foresightRule.js';
-export { instance as LyingSymbolRule } from './lyingSymbolRule.js';
-export { instance as MusicGridRule } from './musicGridRule.js';
-export { instance as MysteryRule } from './mysteryRule.js';
-export { instance as NoLoopsRule } from './noLoopsRule.js';
-export { instance as OffByXRule } from './offByXRule.js';
-export { instance as PerfectionRule } from './perfectionRule.js';
-export { instance as RegionAreaRule } from './regionAreaRule.js';
-export { instance as SameCountPerZoneRule } from './sameCountPerZoneRule.js';
-export { instance as SameShapeRule } from './sameShapeRule.js';
-export { instance as SymbolsPerRegionRule } from './symbolsPerRegionRule.js';
-export { instance as UndercluedRule } from './undercluedRule.js';
-export { instance as UniqueShapeRule } from './uniqueShapeRule.js';
-export { instance as WrapAroundRule } from './wrapAroundRule.js';

package/dist/src/data/rules/rules.gen.js

@@ -1,27 +0,0 @@
-/* prettier-ignore-start */
-/* eslint-disable */
-// @ts-nocheck
-// noinspection JSUnusedGlobalSymbols
-export { instance as BanPatternRule } from './banPatternRule.js';
-export { instance as CellCountRule } from './cellCountRule.js';
-export { instance as CompletePatternRule } from './completePatternRule.js';
-export { instance as ConnectAllRule } from './connectAllRule.js';
-export { instance as ConnectZonesRule } from './connectZonesRule.js';
-export { instance as ContainsShapeRule } from './containsShapeRule.js';
-export { instance as CustomRule } from './customRule.js';
-export { instance as DifferentCountPerZoneRule } from './differentCountPerZoneRule.js';
-export { instance as ExactCountPerZoneRule } from './exactCountPerZoneRule.js';
-export { instance as ForesightRule } from './foresightRule.js';
-export { instance as LyingSymbolRule } from './lyingSymbolRule.js';
-export { instance as MusicGridRule } from './musicGridRule.js';
-export { instance as MysteryRule } from './mysteryRule.js';
-export { instance as NoLoopsRule } from './noLoopsRule.js';
-export { instance as OffByXRule } from './offByXRule.js';
-export { instance as PerfectionRule } from './perfectionRule.js';
-export { instance as RegionAreaRule } from './regionAreaRule.js';
-export { instance as SameCountPerZoneRule } from './sameCountPerZoneRule.js';
-export { instance as SameShapeRule } from './sameShapeRule.js';
-export { instance as SymbolsPerRegionRule } from './symbolsPerRegionRule.js';
-export { instance as UndercluedRule } from './undercluedRule.js';
-export { instance as UniqueShapeRule } from './uniqueShapeRule.js';
-export { instance as WrapAroundRule } from './wrapAroundRule.js';