@logic-pad/core 0.26.1 → 0.26.2

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "@logic-pad/core",
-  "version": "0.26.1",
+  "version": "0.26.2",
   "type": "module",
   "files": [
     "dist",
     "assets"
   ],
+  "publishConfig": {
+    "access": "public"
+  },
   "homepage": "https://github.com/logic-pad/logic-pad",
   "repository": {
     "type": "git",

package/dist/benchmark/helper.d.ts

@@ -1,21 +0,0 @@
-import { Puzzle } from '../src/data/puzzle.js';
-import CompressorBase from '../src/data/serializer/compressor/compressorBase.js';
-declare class BunCompressor extends CompressorBase {
-    get id(): string;
-    compress(input: string): Promise<string>;
-    decompress(input: string): Promise<string>;
-}
-export declare const bunCompressor: BunCompressor;
-export interface PuzzleEntry {
-    pid: number;
-    difficulty: number;
-    puzzleLink: string;
-}
-export interface BenchmarkEntry {
-    pid: number;
-    supported: boolean;
-    solveTime: number;
-    solveCorrect: boolean;
-}
-export declare function parseLink(link: string): Promise<Puzzle>;
-export {};

package/dist/benchmark/helper.js

@@ -1,34 +0,0 @@
-import { Serializer } from '../src/data/serializer/allSerializers.js';
-import { encode, decode } from 'uint8-to-base64';
-import CompressorBase from '../src/data/serializer/compressor/compressorBase.js';
-const decoder = new TextDecoder();
-const encoder = new TextEncoder();
-class BunCompressor extends CompressorBase {
-    get id() {
-        return 'dfl';
-    }
-    compress(input) {
-        const data = Bun.deflateSync(encoder.encode(input), {
-            library: 'libdeflate',
-            level: 12,
-        });
-        return Promise.resolve(`${this.id}_${encode(data).replace(/\+/g, '-').replace(/\//g, '_')}`);
-    }
-    decompress(input) {
-        const data = decode(input.replace(`${this.id}_`, '').replace(/-/g, '+').replace(/_/g, '/'));
-        const result = Bun.inflateSync(data, {
-            library: 'libdeflate',
-            level: 12,
-        });
-        return Promise.resolve(decoder.decode(result));
-    }
-}
-export const bunCompressor = new BunCompressor();
-export async function parseLink(link) {
-    const url = new URL(link);
-    const data = url.searchParams.get('d');
-    if (data === null) {
-        throw new Error('Missing data parameter');
-    }
-    return Serializer.parsePuzzle(await bunCompressor.decompress(data));
-}

package/dist/benchmark/prepareBench.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/benchmark/prepareBench.js

@@ -1,140 +0,0 @@
-import { parseArgs } from 'util';
-import { allSolvers } from '../src/data/solver/allSolvers.js';
-import { parseLink } from './helper.js';
-import PQueue from 'p-queue';
-const allPuzzlesPath = 'benchmark/data/all_puzzles_logic_pad.json';
-const { values, positionals } = parseArgs({
-    args: Bun.argv,
-    options: {
-        maxTime: {
-            type: 'string',
-            default: '10',
-            short: 't',
-        },
-        maxCount: {
-            type: 'string',
-            default: '99999',
-            short: 'c',
-        },
-        concurrency: {
-            type: 'string',
-            default: '4',
-            short: 'n',
-        },
-        help: {
-            type: 'boolean',
-            short: 'h',
-        },
-    },
-    strict: true,
-    allowPositionals: true,
-});
-positionals.splice(0, 2); // Remove "bun" and script name
-if (values.help || positionals.length !== 1) {
-    console.log(`
-Usage: bun bench:prepare <solver> [options]
-
-Options:
-  -t, --maxTime <number>      Maximum seconds allowed for each solve (default: 10)
-  -c, --maxCount <number>     Maximum number of puzzles included (default: 100)
-  -n, --concurrency <number>  Number of solves to run concurrently (default: 4)
-  -h, --help                  Show this help message
-
-Solver:
-  Name of the solver to benchmark. Available solvers are:
-${[...allSolvers.keys()].map(s => `    - ${s}`).join('\n')}
-`);
-    process.exit(0);
-}
-const maxTime = parseFloat(values.maxTime) * 1000;
-const maxCount = parseInt(values.maxCount);
-const solverName = positionals[0];
-const solver = allSolvers.get(solverName);
-if (!solver) {
-    console.error(`Error: Solver "${solverName}" not found.`);
-    process.exit(1);
-}
-const allPuzzles = (await Bun.file(allPuzzlesPath).json());
-allPuzzles.sort(() => Math.random() - 0.5);
-const results = [];
-const pqueue = new PQueue({ concurrency: 4 });
-function printEntry(benchmarkEntry, entryId, solverId, pid) {
-    if (benchmarkEntry.supported) {
-        console.log(`${solverId}\t| ${entryId} / ${allPuzzles.length}\t| ${pid}\t| ${Number.isNaN(benchmarkEntry.solveTime)
-            ? 'timeout'
-            : `${benchmarkEntry.solveTime.toFixed(0)}ms`} ${benchmarkEntry.solveCorrect ? '✓' : '✗'}`);
-    }
-    else {
-        console.log(`${solverId}\t| ${entryId} / ${allPuzzles.length}\t| ${pid}\t| unsupported`);
-    }
-}
-console.log('Available\t| Selected\t| PID\t| Result');
-for (const entry of allPuzzles) {
-    if (results.filter(r => r.result.solveCorrect && r.result.supported).length >=
-        maxCount) {
-        break;
-    }
-    const puzzle = await parseLink(entry.puzzleLink);
-    void pqueue.add(async () => {
-        if (!solver.isGridSupported(puzzle.grid)) {
-            results.push({
-                puzzle: entry,
-                result: {
-                    pid: entry.pid,
-                    supported: false,
-                    solveTime: Number.NaN,
-                    solveCorrect: false,
-                },
-            });
-            printEntry(results[results.length - 1].result, results.length, solverName, entry.pid);
-            return;
-        }
-        const startTime = performance.now();
-        const abortController = new AbortController();
-        const benchmarkEntry = {
-            pid: entry.pid,
-            supported: true,
-            solveTime: Number.NaN,
-            solveCorrect: false,
-        };
-        let step = 0;
-        const handle = setTimeout(() => {
-            abortController.abort();
-        }, maxTime);
-        try {
-            for await (const solution of solver.solve(puzzle.grid, abortController.signal)) {
-                if (step === 0) {
-                    const solveCorrect = solution?.colorEquals(puzzle.solution) ?? false;
-                    if (!solveCorrect)
-                        break;
-                }
-                else {
-                    benchmarkEntry.solveCorrect = solution === null;
-                    if (benchmarkEntry.solveCorrect)
-                        benchmarkEntry.solveTime = performance.now() - startTime;
-                    break;
-                }
-                step++;
-            }
-        }
-        catch {
-            benchmarkEntry.solveCorrect = false;
-        }
-        clearTimeout(handle);
-        results.push({ puzzle: entry, result: benchmarkEntry });
-        printEntry(results[results.length - 1].result, results.length, solverName, entry.pid);
-    });
-}
-await pqueue.onIdle();
-const selectedPuzzles = results.filter(r => r.result.solveCorrect && r.result.supported);
-const benchmarkEntries = selectedPuzzles.map(r => r.result);
-await Bun.write(`benchmark/data/bench_${solverName}_puzzles.json`, JSON.stringify(selectedPuzzles.map(r => r.puzzle), null, 2));
-await Bun.write(`benchmark/data/bench_${solverName}_results.json`, JSON.stringify(benchmarkEntries, null, 2));
-console.log(`
-Benchmark preparation completed. Selected ${selectedPuzzles.length} puzzles.
-
-- Solver: ${solverName}   Max Time: ${maxTime}ms   Max Count: ${maxCount}
-- Average time: ${benchmarkEntries.filter(e => !Number.isNaN(e.solveTime)).reduce((a, b) => a + b.solveTime, 0) / benchmarkEntries.filter(e => !Number.isNaN(e.solveTime)).length}ms
-- Number of timeouts: ${benchmarkEntries.filter(e => Number.isNaN(e.solveTime)).length}
-- Solve correctness: ${benchmarkEntries.filter(e => e.solveCorrect).length} / ${benchmarkEntries.length}
-`);

package/dist/benchmark/runBench.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/benchmark/runBench.js

@@ -1,206 +0,0 @@
-import { parseArgs } from 'util';
-import { allSolvers } from '../src/data/solver/allSolvers.js';
-import { parseLink } from './helper.js';
-import PQueue from 'p-queue';
-const { values, positionals } = parseArgs({
-    args: Bun.argv,
-    options: {
-        maxTime: {
-            type: 'string',
-            default: '10',
-            short: 't',
-        },
-        maxCount: {
-            type: 'string',
-            default: '99999',
-            short: 'c',
-        },
-        concurrency: {
-            type: 'string',
-            default: '4',
-            short: 'n',
-        },
-        help: {
-            type: 'boolean',
-            short: 'h',
-        },
-    },
-    strict: true,
-    allowPositionals: true,
-});
-positionals.splice(0, 2); // Remove "bun" and script name
-if (values.help || positionals.length === 0) {
-    console.log(`
-Usage: bun bench:run <solver> [options]
-
-Options:
-  -t, --maxTime <number>       Maximum seconds allowed for each solve (default: 10)
-  -c, --maxCount <number>      Maximum number of puzzles included (default: 100)
-  -n, --concurrency <number>   Number of solves to run concurrently (default: 4)
-  -h, --help                   Show this help message
-
-Solvers available for benchmarking:
-${[...allSolvers.keys()].map(s => `    - ${s}`).join('\n')}
-`);
-    process.exit(0);
-}
-const maxTime = parseFloat(values.maxTime) * 1000;
-const maxCount = parseInt(values.maxCount);
-const concurrency = parseInt(values.concurrency);
-for (const name of positionals) {
-    if (!allSolvers.has(name)) {
-        console.error(`Error: Solver "${name}" not found.`);
-        process.exit(1);
-    }
-}
-const allPuzzles = (await Bun.file(`benchmark/data/bench_${positionals[0]}_puzzles.json`).json());
-allPuzzles.sort(() => Math.random() - 0.5);
-allPuzzles.splice(maxCount);
-const benchmarkEntries = Object.fromEntries(positionals.map(name => [
-    name,
-    allPuzzles.map(p => ({
-        pid: p.pid,
-        supported: false,
-        solveTime: Number.NaN,
-        solveCorrect: false,
-    })),
-]));
-const pqueue = new PQueue({ concurrency });
-function printEntry(benchmarkEntry, entryId, solverId, pid) {
-    if (benchmarkEntry.supported) {
-        console.log(`${solverId}\t| ${entryId} / ${allPuzzles.length}\t| ${pid}\t| ${Number.isNaN(benchmarkEntry.solveTime)
-            ? 'timeout'
-            : `${benchmarkEntry.solveTime.toFixed(0)}ms`} ${benchmarkEntry.solveCorrect ? '✓' : '✗'}`);
-    }
-    else {
-        console.log(`${solverId}\t| ${entryId} / ${allPuzzles.length}\t| ${pid}\t| unsupported`);
-    }
-}
-console.log('Solver     \t| Trial     \t| PID\t| Result');
-console.log();
-for (let i = 0; i < allPuzzles.length; i++) {
-    const entry = allPuzzles[i];
-    const solvers = positionals.slice().sort(() => Math.random() - 0.5);
-    const puzzle = await parseLink(entry.puzzleLink);
-    for (const solverId of solvers) {
-        const solver = allSolvers.get(solverId);
-        void pqueue.add(async () => {
-            if (!solver.isGridSupported(puzzle.grid)) {
-                benchmarkEntries[solverId][i] = {
-                    pid: entry.pid,
-                    supported: false,
-                    solveTime: Number.NaN,
-                    solveCorrect: false,
-                };
-                printEntry(benchmarkEntries[solverId][i], i + 1, solverId, entry.pid);
-                return;
-            }
-            const startTime = performance.now();
-            const abortController = new AbortController();
-            const benchmarkEntry = {
-                pid: entry.pid,
-                supported: true,
-                solveTime: Number.NaN,
-                solveCorrect: false,
-            };
-            let step = 0;
-            const handle = setTimeout(() => {
-                abortController.abort();
-            }, maxTime);
-            try {
-                for await (const solution of solver.solve(puzzle.grid, abortController.signal)) {
-                    if (step === 0) {
-                        const solveCorrect = solution?.colorEquals(puzzle.solution) ?? false;
-                        if (!solveCorrect)
-                            break;
-                    }
-                    else {
-                        benchmarkEntry.solveCorrect = solution === null;
-                        if (benchmarkEntry.solveCorrect)
-                            benchmarkEntry.solveTime = performance.now() - startTime;
-                        break;
-                    }
-                    step++;
-                }
-            }
-            catch {
-                benchmarkEntry.solveCorrect = false;
-            }
-            clearTimeout(handle);
-            benchmarkEntries[solverId][i] = benchmarkEntry;
-            printEntry(benchmarkEntry, i + 1, solverId, entry.pid);
-        });
-    }
-}
-await pqueue.onIdle();
-const results = positionals.map(name => ({
-    solver: name,
-    fastestCount: 0,
-    solve25: 0,
-    solve50: 0,
-    solve75: 0,
-    solveSD: 0,
-    unsupportedCount: 0,
-    incorrectCount: 0,
-}));
-for (let i = 0; i < benchmarkEntries[positionals[0]].length; i++) {
-    let fastestSolveTime = Number.POSITIVE_INFINITY;
-    let fastestSolverIndex = null;
-    for (let j = 0; j < positionals.length; j++) {
-        const entry = benchmarkEntries[positionals[j]][i];
-        if (!entry.supported) {
-            results[j].unsupportedCount++;
-            continue;
-        }
-        if (entry.solveCorrect && !Number.isNaN(entry.solveTime)) {
-            if (entry.solveTime < fastestSolveTime) {
-                fastestSolveTime = entry.solveTime;
-                fastestSolverIndex = j;
-            }
-        }
-        else {
-            results[j].incorrectCount++;
-        }
-    }
-    if (fastestSolverIndex !== null) {
-        results[fastestSolverIndex].fastestCount++;
-    }
-}
-for (let j = 0; j < positionals.length; j++) {
-    const entries = benchmarkEntries[positionals[j]].filter(e => e.supported && e.solveCorrect && !Number.isNaN(e.solveTime));
-    // 25th percentile
-    const times = entries.map(e => e.solveTime).sort((a, b) => a - b);
-    results[j].solve25 =
-        times.length === 0
-            ? Number.NaN
-            : times[Math.floor((times.length - 1) * 0.25)];
-    // 50th percentile (median)
-    results[j].solve50 =
-        times.length === 0
-            ? Number.NaN
-            : times[Math.floor((times.length - 1) * 0.5)];
-    // 75th percentile
-    results[j].solve75 =
-        times.length === 0
-            ? Number.NaN
-            : times[Math.floor((times.length - 1) * 0.75)];
-    // Standard deviation
-    const mean = times.reduce((sum, time) => sum + time, 0) / (times.length || 1);
-    const variance = times.reduce((sum, time) => sum + (time - mean) ** 2, 0) /
-        (times.length || 1);
-    results[j].solveSD = Math.sqrt(variance);
-}
-console.log('\nBenchmark Results:');
-for (const result of results) {
-    console.log(`
-${result.solver}:
-  Fastest Solves: ${result.fastestCount}
-  Solve time:
-    P25: ${Number.isNaN(result.solve25) ? 'N/A' : `${result.solve25.toFixed(2)}ms`}
-    P50: ${Number.isNaN(result.solve50) ? 'N/A' : `${result.solve50.toFixed(2)}ms`}
-    P75: ${Number.isNaN(result.solve75) ? 'N/A' : `${result.solve75.toFixed(2)}ms`}
-    SD:  ${Number.isNaN(result.solveSD) ? 'N/A' : `${result.solveSD.toFixed(2)}ms`}
-  Unsupported Puzzles: ${result.unsupportedCount}
-  Incorrect Solutions: ${result.incorrectCount}
-`);
-}

package/dist/src/data/config.d.ts

@@ -1,119 +0,0 @@
-import GridData from './grid.js';
-import { Color, Comparison, Direction, DirectionToggle, Instrument, Orientation, OrientationToggle, Position, Wrapping } from './primitives.js';
-import { ControlLine } from './rules/musicControlLine.js';
-export declare enum ConfigType {
-    Boolean = "boolean",
-    NullableBoolean = "nullableBoolean",
-    Number = "number",
-    NullableNumber = "nullableNumber",
-    String = "string",
-    Color = "color",
-    Comparison = "comparison",
-    Wrapping = "wrapping",
-    Direction = "direction",
-    DirectionToggle = "directionToggle",
-    Orientation = "orientation",
-    OrientationToggle = "orientationToggle",
-    Tile = "tile",
-    Shape = "shape",
-    Grid = "grid",
-    NullableGrid = "nullableGrid",
-    Icon = "icon",
-    ControlLines = "controlLines",
-    NullableNote = "nullableNote",
-    NullableInstrument = "nullableInstrument",
-    SolvePath = "solvePath"
-}
-export interface Config<T> {
-    readonly type: ConfigType;
-    readonly field: string;
-    readonly description: string;
-    readonly explanation?: string;
-    readonly default: T;
-    readonly configurable: boolean;
-}
-export interface BooleanConfig extends Config<boolean> {
-    readonly type: ConfigType.Boolean;
-}
-export interface NullableBooleanConfig extends Config<boolean | null> {
-    readonly type: ConfigType.NullableBoolean;
-}
-export interface NumberConfig extends Config<number> {
-    readonly type: ConfigType.Number;
-    readonly min?: number;
-    readonly max?: number;
-    readonly step?: number;
-}
-export interface NullableNumberConfig extends Config<number | null> {
-    readonly type: ConfigType.NullableNumber;
-    readonly min?: number;
-    readonly max?: number;
-    readonly step?: number;
-}
-export interface StringConfig extends Config<string> {
-    readonly type: ConfigType.String;
-    readonly maxLength?: number;
-    readonly placeholder?: string;
-}
-export interface ColorConfig extends Config<Color> {
-    readonly type: ConfigType.Color;
-    readonly allowGray: boolean;
-}
-export interface ComparisonConfig extends Config<Comparison> {
-    readonly type: ConfigType.Comparison;
-}
-export interface WrappingConfig extends Config<Wrapping> {
-    readonly type: ConfigType.Wrapping;
-}
-export interface DirectionConfig extends Config<Direction> {
-    readonly type: ConfigType.Direction;
-}
-export interface DirectionToggleConfig extends Config<DirectionToggle> {
-    readonly type: ConfigType.DirectionToggle;
-}
-export interface OrientationConfig extends Config<Orientation> {
-    readonly type: ConfigType.Orientation;
-}
-export interface OrientationToggleConfig extends Config<OrientationToggle> {
-    readonly type: ConfigType.OrientationToggle;
-}
-export interface TileConfig extends Config<GridData> {
-    readonly type: ConfigType.Tile;
-    readonly resizable: boolean;
-}
-export interface ShapeConfig extends Config<GridData> {
-    readonly type: ConfigType.Shape;
-    readonly resizable: boolean;
-}
-export interface GridConfig extends Config<GridData> {
-    readonly type: ConfigType.Grid;
-}
-export interface NullableGridConfig extends Config<GridData | null> {
-    readonly type: ConfigType.NullableGrid;
-    readonly nonNullDefault: GridData;
-}
-export interface IconConfig extends Config<string> {
-    readonly type: ConfigType.Icon;
-}
-export interface ControlLinesConfig extends Config<ControlLine[]> {
-    readonly type: ConfigType.ControlLines;
-}
-export interface NullableNoteConfig extends Config<string | null> {
-    readonly type: ConfigType.NullableNote;
-}
-export interface NullableInstrumentConfig extends Config<Instrument | null> {
-    readonly type: ConfigType.NullableInstrument;
-}
-export interface SolvePathConfig extends Config<Position[]> {
-    readonly type: ConfigType.SolvePath;
-}
-export type AnyConfig = BooleanConfig | NullableBooleanConfig | NumberConfig | NullableNumberConfig | StringConfig | ColorConfig | ComparisonConfig | WrappingConfig | DirectionConfig | DirectionToggleConfig | OrientationConfig | OrientationToggleConfig | TileConfig | ShapeConfig | GridConfig | NullableGridConfig | IconConfig | ControlLinesConfig | NullableNoteConfig | NullableInstrumentConfig | SolvePathConfig;
-/**
- * Compare two config values for equality, using an appropriate method for the config type.
- *
- * @param type The type of the config.
- * @param a The first value to compare.
- * @param b The second value to compare.
- * @returns Whether the two values are equal.
- */
-export declare function configEquals<C extends AnyConfig>(type: C['type'], a: C['default'], b: C['default']): boolean;

package/dist/src/data/config.js

@@ -1,72 +0,0 @@
-import { DIRECTIONS, ORIENTATIONS, } from './primitives.js';
-import { normalizeShape, shapeEquals, tilesToShape } from './shapes.js';
-export var ConfigType;
-(function (ConfigType) {
-    ConfigType["Boolean"] = "boolean";
-    ConfigType["NullableBoolean"] = "nullableBoolean";
-    ConfigType["Number"] = "number";
-    ConfigType["NullableNumber"] = "nullableNumber";
-    ConfigType["String"] = "string";
-    ConfigType["Color"] = "color";
-    ConfigType["Comparison"] = "comparison";
-    ConfigType["Wrapping"] = "wrapping";
-    ConfigType["Direction"] = "direction";
-    ConfigType["DirectionToggle"] = "directionToggle";
-    ConfigType["Orientation"] = "orientation";
-    ConfigType["OrientationToggle"] = "orientationToggle";
-    ConfigType["Tile"] = "tile";
-    ConfigType["Shape"] = "shape";
-    ConfigType["Grid"] = "grid";
-    ConfigType["NullableGrid"] = "nullableGrid";
-    ConfigType["Icon"] = "icon";
-    ConfigType["ControlLines"] = "controlLines";
-    ConfigType["NullableNote"] = "nullableNote";
-    ConfigType["NullableInstrument"] = "nullableInstrument";
-    ConfigType["SolvePath"] = "solvePath";
-})(ConfigType || (ConfigType = {}));
-/**
- * Compare two config values for equality, using an appropriate method for the config type.
- *
- * @param type The type of the config.
- * @param a The first value to compare.
- * @param b The second value to compare.
- * @returns Whether the two values are equal.
- */
-export function configEquals(type, a, b) {
-    if (type === ConfigType.ControlLines) {
-        const aLines = a;
-        const bLines = b;
-        if (aLines.length !== bLines.length)
-            return false;
-        return aLines.every((line, i) => line.equals(bLines[i]));
-    }
-    if (type === ConfigType.Tile || type === ConfigType.Grid) {
-        return a.equals(b);
-    }
-    if (type === ConfigType.Shape) {
-        const aShape = normalizeShape(tilesToShape(a.tiles));
-        const bShape = normalizeShape(tilesToShape(b.tiles));
-        return shapeEquals(aShape, bShape);
-    }
-    if (type === ConfigType.NullableGrid) {
-        if (a === null && b === null)
-            return true;
-        if (a === null || b === null)
-            return false;
-        return a.equals(b);
-    }
-    if (type === ConfigType.DirectionToggle) {
-        return DIRECTIONS.every(dir => a[dir] === b[dir]);
-    }
-    if (type === ConfigType.OrientationToggle) {
-        return ORIENTATIONS.every(dir => a[dir] === b[dir]);
-    }
-    if (type === ConfigType.SolvePath) {
-        const aPath = a;
-        const bPath = b;
-        if (aPath.length !== bPath.length)
-            return false;
-        return aPath.every((pos, i) => pos.x === bPath[i].x && pos.y === bPath[i].y);
-    }
-    return a === b;
-}

package/dist/src/data/configurable.d.ts

@@ -1,14 +0,0 @@
-import { AnyConfig } from './config.js';
-export default abstract class Configurable {
-    abstract get title(): string;
-    abstract get configExplanation(): string;
-    get configs(): readonly AnyConfig[] | null;
-    abstract copyWith(props: Record<string, unknown>): this;
-    /**
-     * Check if this instruction is equal to another instruction by comparing their IDs and configs.
-     *
-     * @param other The other instruction to compare to.
-     * @returns Whether the two instructions are equal.
-     */
-    equals(other: Configurable): boolean;
-}

package/dist/src/data/configurable.js

@@ -1,26 +0,0 @@
-import { configEquals } from './config.js';
-export default class Configurable {
-    get configs() {
-        return null;
-    }
-    /**
-     * Check if this instruction is equal to another instruction by comparing their IDs and configs.
-     *
-     * @param other The other instruction to compare to.
-     * @returns Whether the two instructions are equal.
-     */
-    equals(other) {
-        const configs = this.configs;
-        if (configs === null)
-            return true;
-        // this is only possible when an instruction is instantiated before the class itself is completely defined
-        // in this case, we can only compare the instances themselves
-        if (configs === undefined)
-            return this === other;
-        for (const config of this.configs) {
-            if (!configEquals(config.type, this[config.field], other[config.field]))
-                return false;
-        }
-        return true;
-    }
-}