@turing-machine-js/machine 3.0.0 → 3.0.2

package/dist/classes/Tape.js

@@ -1,95 +0,0 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Tape_alphabet, _Tape_symbols, _Tape_position, _Tape_viewportWidth;
-import Alphabet from './Alphabet';
-class Tape {
-    constructor({ alphabet, symbols = [], position = 0, viewportWidth = 1, }) {
-        _Tape_alphabet.set(this, void 0);
-        _Tape_symbols.set(this, void 0);
-        _Tape_position.set(this, void 0);
-        _Tape_viewportWidth.set(this, void 0);
-        const isSymbolsValid = symbols.every((symbol) => alphabet.has(symbol));
-        if (!isSymbolsValid) {
-            throw new Error('symbolList contains invalid symbol');
-        }
-        __classPrivateFieldSet(this, _Tape_alphabet, new Alphabet(alphabet), "f");
-        __classPrivateFieldSet(this, _Tape_position, position, "f");
-        __classPrivateFieldSet(this, _Tape_viewportWidth, viewportWidth, "f");
-        const symbolsCopy = Array.from(symbols);
-        if (symbolsCopy.length === 0) {
-            symbolsCopy.push(__classPrivateFieldGet(this, _Tape_alphabet, "f").blankSymbol);
-        }
-        __classPrivateFieldSet(this, _Tape_symbols, symbolsCopy.map((symbol) => __classPrivateFieldGet(this, _Tape_alphabet, "f").index(symbol)), "f");
-    }
-    get alphabet() {
-        return __classPrivateFieldGet(this, _Tape_alphabet, "f");
-    }
-    get extraCellsCount() {
-        return (__classPrivateFieldGet(this, _Tape_viewportWidth, "f") - 1) / 2;
-    }
-    get position() {
-        return __classPrivateFieldGet(this, _Tape_position, "f");
-    }
-    get symbol() {
-        return __classPrivateFieldGet(this, _Tape_alphabet, "f").get(__classPrivateFieldGet(this, _Tape_symbols, "f")[__classPrivateFieldGet(this, _Tape_position, "f")]);
-    }
-    set symbol(symbol) {
-        if (!__classPrivateFieldGet(this, _Tape_alphabet, "f").has(symbol)) {
-            throw new Error('Invalid symbol');
-        }
-        __classPrivateFieldGet(this, _Tape_symbols, "f")[__classPrivateFieldGet(this, _Tape_position, "f")] = __classPrivateFieldGet(this, _Tape_alphabet, "f").index(symbol);
-    }
-    get symbols() {
-        return __classPrivateFieldGet(this, _Tape_symbols, "f")
-            .map((index) => __classPrivateFieldGet(this, _Tape_alphabet, "f").get(index));
-    }
-    get viewport() {
-        const startIx = __classPrivateFieldGet(this, _Tape_position, "f") - this.extraCellsCount;
-        const endIx = __classPrivateFieldGet(this, _Tape_position, "f") + this.extraCellsCount + 1;
-        return __classPrivateFieldGet(this, _Tape_symbols, "f")
-            .slice(startIx, endIx)
-            .map((index) => __classPrivateFieldGet(this, _Tape_alphabet, "f").get(index));
-    }
-    get viewportWidth() {
-        return __classPrivateFieldGet(this, _Tape_viewportWidth, "f");
-    }
-    set viewportWidth(width) {
-        let finalWidth = width;
-        if (finalWidth < 1) {
-            throw new Error('Invalid viewportWidth');
-        }
-        if (finalWidth % 2 === 0) {
-            finalWidth += 1;
-        }
-        __classPrivateFieldSet(this, _Tape_viewportWidth, finalWidth, "f");
-        this.normalise();
-    }
-    left() {
-        __classPrivateFieldSet(this, _Tape_position, __classPrivateFieldGet(this, _Tape_position, "f") - 1, "f");
-        this.normalise();
-    }
-    normalise() {
-        while (__classPrivateFieldGet(this, _Tape_position, "f") - this.extraCellsCount < 0) {
-            __classPrivateFieldGet(this, _Tape_symbols, "f").unshift(0);
-            __classPrivateFieldSet(this, _Tape_position, __classPrivateFieldGet(this, _Tape_position, "f") + 1, "f");
-        }
-        while (__classPrivateFieldGet(this, _Tape_position, "f") + this.extraCellsCount >= __classPrivateFieldGet(this, _Tape_symbols, "f").length) {
-            __classPrivateFieldGet(this, _Tape_symbols, "f").push(0);
-        }
-    }
-    right() {
-        __classPrivateFieldSet(this, _Tape_position, __classPrivateFieldGet(this, _Tape_position, "f") + 1, "f");
-        this.normalise();
-    }
-}
-_Tape_alphabet = new WeakMap(), _Tape_symbols = new WeakMap(), _Tape_position = new WeakMap(), _Tape_viewportWidth = new WeakMap();
-export default Tape;

package/dist/classes/TapeBlock.js

@@ -1,197 +0,0 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _a, _TapeBlock_symbolToPatternListMap, _TapeBlock_lock, _TapeBlock_tapes, _TapeBlock_generateSymbolHint, _TapeBlock_buildPatternList, _TapeBlock_getSymbolForPatternList, _TapeBlock_symbol;
-import Tape from './Tape';
-import { ifOtherSymbol } from './State';
-import { movements, symbolCommands } from './TapeCommand';
-import Lock from './Lock';
-const symbolToPatternListMapSymbol = Symbol('symbol for symbolToPatternListMap setter');
-export const lockSymbol = Symbol('capture symbol');
-class TapeBlock {
-    constructor(argument) {
-        _TapeBlock_symbolToPatternListMap.set(this, new Map());
-        _TapeBlock_lock.set(this, new Lock());
-        _TapeBlock_tapes.set(this, void 0);
-        _TapeBlock_buildPatternList.set(this, (symbolList) => symbolList.reduce((result, symbol, ix) => {
-            const row = Math.floor(ix / __classPrivateFieldGet(this, _TapeBlock_tapes, "f").length);
-            if (!Array.isArray(result[row])) {
-                result[row] = [];
-            }
-            result[row].push(symbol);
-            return result;
-        }, [])
-            .filter((pattern, ix, patternList) => {
-            const samePatternIx = patternList.findIndex((otherPattern) => (pattern
-                .every((symbol, symbolIx) => symbol === otherPattern[symbolIx])));
-            return samePatternIx === ix;
-        }));
-        _TapeBlock_getSymbolForPatternList.set(this, (patternList) => {
-            if (patternList.some((pattern) => pattern.every((symbol) => symbol === ifOtherSymbol))) {
-                return ifOtherSymbol;
-            }
-            const [storedPatternListSymbol] = [...__classPrivateFieldGet(this, _TapeBlock_symbolToPatternListMap, "f").entries()]
-                .find(([, storedPatternList]) => {
-                if (storedPatternList.length !== patternList.length) {
-                    return false;
-                }
-                return patternList
-                    .every((pattern, patternIx) => pattern
-                    .every((symbol, symbolIx) => symbol === storedPatternList[patternIx][symbolIx]));
-            }) || [null, null];
-            let symbol;
-            if (storedPatternListSymbol) {
-                symbol = storedPatternListSymbol;
-            }
-            else {
-                symbol = Symbol(__classPrivateFieldGet(_a, _a, "f", _TapeBlock_generateSymbolHint).call(_a, patternList));
-                __classPrivateFieldGet(this, _TapeBlock_symbolToPatternListMap, "f").set(symbol, patternList);
-            }
-            return symbol;
-        });
-        _TapeBlock_symbol.set(this, (symbols) => {
-            let localSymbols = [];
-            if (symbols === ifOtherSymbol) {
-                return ifOtherSymbol;
-            }
-            if (typeof symbols === 'string') {
-                localSymbols = symbols.split('');
-            }
-            else if (Array.isArray(symbols)) {
-                localSymbols = [...symbols];
-            }
-            if (localSymbols.length === 0 || localSymbols.length % __classPrivateFieldGet(this, _TapeBlock_tapes, "f").length > 0) {
-                throw new Error('invalid symbol parameter');
-            }
-            const invalidSymbolIndex = localSymbols.findIndex((symbol, ix) => (symbol !== ifOtherSymbol
-                && !__classPrivateFieldGet(this, _TapeBlock_tapes, "f")[ix % __classPrivateFieldGet(this, _TapeBlock_tapes, "f").length].alphabet.has(symbol)));
-            if (invalidSymbolIndex >= 0) {
-                throw new Error('invalid symbol parameter');
-            }
-            if (localSymbols.every((symbol) => symbol === ifOtherSymbol)) {
-                return ifOtherSymbol;
-            }
-            return __classPrivateFieldGet(this, _TapeBlock_getSymbolForPatternList, "f").call(this, __classPrivateFieldGet(this, _TapeBlock_buildPatternList, "f").call(this, localSymbols));
-        });
-        __classPrivateFieldSet(this, _TapeBlock_tapes, [], "f");
-        if ('alphabets' in argument) {
-            const { alphabets } = argument;
-            if (alphabets.length === 0) {
-                throw new Error('empty alphabet list');
-            }
-            __classPrivateFieldSet(this, _TapeBlock_tapes, alphabets.map((alphabet) => new Tape({
-                alphabet,
-            })), "f");
-        }
-        else if ('tapes' in argument) {
-            __classPrivateFieldSet(this, _TapeBlock_tapes, argument.tapes, "f");
-        }
-        if (__classPrivateFieldGet(this, _TapeBlock_tapes, "f").length === 0) {
-            throw new Error('empty tape list');
-        }
-    }
-    get alphabets() {
-        return [...__classPrivateFieldGet(this, _TapeBlock_tapes, "f").map((tape) => tape.alphabet)];
-    }
-    get currentSymbols() {
-        return __classPrivateFieldGet(this, _TapeBlock_tapes, "f").map((tape) => tape.symbol);
-    }
-    get [(_TapeBlock_symbolToPatternListMap = new WeakMap(), _TapeBlock_lock = new WeakMap(), _TapeBlock_tapes = new WeakMap(), _TapeBlock_buildPatternList = new WeakMap(), _TapeBlock_getSymbolForPatternList = new WeakMap(), _TapeBlock_symbol = new WeakMap(), lockSymbol)]() {
-        return __classPrivateFieldGet(this, _TapeBlock_lock, "f");
-    }
-    get symbol() {
-        return __classPrivateFieldGet(this, _TapeBlock_symbol, "f").bind(this);
-    }
-    get tapes() {
-        return [...__classPrivateFieldGet(this, _TapeBlock_tapes, "f")];
-    }
-    set [symbolToPatternListMapSymbol](symbolToPatternListMap) {
-        __classPrivateFieldSet(this, _TapeBlock_symbolToPatternListMap, new Map(symbolToPatternListMap), "f");
-    }
-    applyCommand(command, executionSymbol = null) {
-        __classPrivateFieldGet(this, _TapeBlock_lock, "f").check(executionSymbol);
-        if (__classPrivateFieldGet(this, _TapeBlock_tapes, "f").length !== command.tapesCommands.length) {
-            throw new Error('invalid command');
-        }
-        __classPrivateFieldGet(this, _TapeBlock_tapes, "f").forEach((tape, ix) => {
-            const { movement, symbol } = command.tapesCommands[ix];
-            if (typeof symbol === 'string') {
-                tape.symbol = symbol;
-            }
-            if (typeof symbol === 'symbol') {
-                switch (symbol) {
-                    case symbolCommands.keep:
-                        break;
-                    case symbolCommands.erase:
-                        tape.symbol = tape.alphabet.blankSymbol;
-                        break;
-                    // no default
-                }
-            }
-            switch (movement) {
-                case movements.left:
-                    tape.left();
-                    break;
-                case movements.stay:
-                    break;
-                case movements.right:
-                    tape.right();
-                    break;
-                // no default
-            }
-        });
-    }
-    clone(cloneTapes = false) {
-        let tapeBlock;
-        if (cloneTapes) {
-            tapeBlock = _a.fromTapes(this.tapes.map((tape) => new Tape(tape)));
-        }
-        else {
-            tapeBlock = _a.fromAlphabets(this.alphabets);
-        }
-        tapeBlock[symbolToPatternListMapSymbol] = __classPrivateFieldGet(this, _TapeBlock_symbolToPatternListMap, "f");
-        return tapeBlock;
-    }
-    isMatched({ currentSymbols = this.currentSymbols, symbol }) {
-        if (symbol === ifOtherSymbol) {
-            return true;
-        }
-        if (!__classPrivateFieldGet(this, _TapeBlock_symbolToPatternListMap, "f").has(symbol)) {
-            throw new Error('invalid symbol');
-        }
-        const patternList = __classPrivateFieldGet(this, _TapeBlock_symbolToPatternListMap, "f").get(symbol);
-        return patternList?.some((pattern) => (pattern
-            .every((everySymbol, ix) => (everySymbol === ifOtherSymbol
-            || everySymbol === currentSymbols[ix])))) ?? false;
-    }
-    replaceTape(tape, tapeIx = 0) {
-        if (__classPrivateFieldGet(this, _TapeBlock_tapes, "f")[tapeIx] == null) {
-            throw new Error('invalid tapeIx');
-        }
-        if (tape.alphabet.symbols.join('') === __classPrivateFieldGet(this, _TapeBlock_tapes, "f")[tapeIx].alphabet.symbols.join('')) {
-            __classPrivateFieldGet(this, _TapeBlock_tapes, "f")[tapeIx] = tape;
-        }
-        else {
-            throw new Error('invalid tape');
-        }
-    }
-}
-_a = TapeBlock;
-TapeBlock.fromAlphabets = (alphabets) => {
-    return new _a({ alphabets });
-};
-TapeBlock.fromTapes = (tapes) => {
-    return new _a({ tapes });
-};
-_TapeBlock_generateSymbolHint = { value: (patternList) => JSON.stringify(patternList
-        .map((pattern) => pattern
-        .map((symbol) => (symbol === ifOtherSymbol ? null : symbol)))) };
-export default TapeBlock;

package/dist/classes/TapeCommand.js

@@ -1,46 +0,0 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _TapeCommand_movement, _TapeCommand_symbol;
-export const movements = {
-    left: Symbol('move caret left command'),
-    right: Symbol('move caret right command'),
-    stay: Symbol('do not move carer'),
-};
-export const symbolCommands = {
-    erase: Symbol('erase symbol command'),
-    keep: Symbol('keep symbol command'),
-};
-class TapeCommand {
-    constructor({ movement = movements.stay, symbol = symbolCommands.keep, }) {
-        _TapeCommand_movement.set(this, void 0);
-        _TapeCommand_symbol.set(this, void 0);
-        const isValidMovement = [movements.left, movements.stay, movements.right].includes(movement);
-        if (!isValidMovement) {
-            throw new Error('invalid movement');
-        }
-        __classPrivateFieldSet(this, _TapeCommand_movement, movement, "f");
-        const isValidSymbol = ((typeof symbol === 'string' && symbol.length === 1)
-            || [symbolCommands.keep, symbolCommands.erase].includes(symbol));
-        if (!isValidSymbol) {
-            throw new Error('invalid symbol');
-        }
-        __classPrivateFieldSet(this, _TapeCommand_symbol, symbol, "f");
-    }
-    get symbol() {
-        return __classPrivateFieldGet(this, _TapeCommand_symbol, "f");
-    }
-    get movement() {
-        return __classPrivateFieldGet(this, _TapeCommand_movement, "f");
-    }
-}
-_TapeCommand_movement = new WeakMap(), _TapeCommand_symbol = new WeakMap();
-export default TapeCommand;

package/dist/classes/TuringMachine.js

@@ -1,102 +0,0 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _TuringMachine_tapeBlock, _TuringMachine_stack;
-import { haltState } from './State';
-import { lockSymbol } from './TapeBlock';
-import { symbolCommands } from './TapeCommand';
-class TuringMachine {
-    constructor({ tapeBlock, } = {}) {
-        _TuringMachine_tapeBlock.set(this, void 0);
-        _TuringMachine_stack.set(this, []);
-        if (!tapeBlock) {
-            throw new Error('invalid tapeBlock');
-        }
-        __classPrivateFieldSet(this, _TuringMachine_tapeBlock, tapeBlock, "f");
-    }
-    get tapeBlock() {
-        return __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f");
-    }
-    run({ initialState, stepsLimit = 1e5, onStep }) {
-        const generator = this.runStepByStep({ initialState, stepsLimit });
-        for (const machineState of generator) {
-            if (onStep instanceof Function) {
-                onStep(machineState);
-            }
-        }
-    }
-    *runStepByStep({ initialState, stepsLimit = 1e5 }) {
-        const executionSymbol = Symbol('execution');
-        try {
-            __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f")[lockSymbol].check(executionSymbol);
-            __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f")[lockSymbol].lock(executionSymbol);
-            const stack = __classPrivateFieldGet(this, _TuringMachine_stack, "f");
-            let state = initialState;
-            if (state.overrodeHaltState) {
-                stack.push(state.overrodeHaltState);
-            }
-            let i = 0;
-            while (!state.isHalt) {
-                if (i === stepsLimit) {
-                    throw new Error('Long execution');
-                }
-                i += 1;
-                const symbol = state.getSymbol(__classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f"));
-                const command = state.getCommand(symbol);
-                let nextState = state.getNextState(symbol).ref;
-                try {
-                    const nextStateForYield = nextState.isHalt && stack.length
-                        ? stack.slice(-1)[0]
-                        : nextState;
-                    yield {
-                        step: i,
-                        state,
-                        currentSymbols: __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f").currentSymbols,
-                        nextSymbols: command.tapesCommands.map((tapeCommand, ix) => {
-                            if (typeof tapeCommand.symbol === 'symbol') {
-                                switch (tapeCommand.symbol) {
-                                    case symbolCommands.erase:
-                                        return __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f").tapes[ix].alphabet.blankSymbol;
-                                    case symbolCommands.keep:
-                                        return __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f").tapes[ix].symbol;
-                                    default:
-                                        throw new Error('invalid symbol command');
-                                }
-                            }
-                            return tapeCommand.symbol;
-                        }),
-                        movements: command.tapesCommands.map((tapeCommand) => tapeCommand.movement),
-                        nextState: nextStateForYield,
-                    };
-                    __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f").applyCommand(command, executionSymbol);
-                    if (nextState.isHalt && stack.length) {
-                        nextState = stack.pop();
-                    }
-                    if (state !== nextState && nextState.overrodeHaltState) {
-                        stack.push(nextState.overrodeHaltState);
-                    }
-                    state = nextState;
-                }
-                catch (error) {
-                    if (error !== haltState) {
-                        throw error;
-                    }
-                    break;
-                }
-            }
-        }
-        finally {
-            __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f")[lockSymbol].unlock(executionSymbol);
-        }
-    }
-}
-_TuringMachine_tapeBlock = new WeakMap(), _TuringMachine_stack = new WeakMap();
-export default TuringMachine;

package/dist/index.js

@@ -1,11 +0,0 @@
-export { default as Alphabet } from './classes/Alphabet';
-export { default as Command } from './classes/Command';
-export { default as Reference } from './classes/Reference';
-export { default as State, haltState, ifOtherSymbol } from './classes/State';
-export { default as Tape } from './classes/Tape';
-export { default as TapeBlock } from './classes/TapeBlock';
-export { default as TapeCommand, movements, symbolCommands } from './classes/TapeCommand';
-export { default as TuringMachine } from './classes/TuringMachine';
-export { toMermaid, fromMermaid } from './utilities/graphFormats';
-export { summarize, summarizeGraph } from './utilities/introspection';
-export { equivalentOn, } from './utilities/equivalence';

package/dist/utilities/equivalence.js

@@ -1,68 +0,0 @@
-import Tape from '../classes/Tape';
-import TuringMachine from '../classes/TuringMachine';
-const defaultCompare = (a, b) => a === b;
-export function equivalentOn(reference, candidate, cases, options = {}) {
-    const compareOutputs = options.compareOutputs ?? defaultCompare;
-    const compareSnapshots = options.compareSnapshots === undefined
-        ? defaultCompare
-        : options.compareSnapshots;
-    const stepsLimit = options.stepsLimit ?? 1e5;
-    const results = cases.map((c) => {
-        const pair = typeof c === 'string' ? { reference: c, candidate: c } : c;
-        const refRun = runOnce(reference, pair.reference, stepsLimit);
-        const candRun = runOnce(candidate, pair.candidate, stepsLimit);
-        const agree = compareOutputs(refRun.finalOutput, candRun.finalOutput);
-        let firstDivergenceStep = null;
-        if (!agree && compareSnapshots !== null) {
-            const minLen = Math.min(refRun.snapshots.length, candRun.snapshots.length);
-            for (let i = 0; i < minLen; i += 1) {
-                if (!compareSnapshots(refRun.snapshots[i], candRun.snapshots[i])) {
-                    firstDivergenceStep = i;
-                    break;
-                }
-            }
-            if (firstDivergenceStep === null && refRun.snapshots.length !== candRun.snapshots.length) {
-                firstDivergenceStep = minLen;
-            }
-        }
-        return {
-            case: pair,
-            agree,
-            referenceOutput: refRun.finalOutput,
-            candidateOutput: candRun.finalOutput,
-            referenceSteps: refRun.stepCount,
-            candidateSteps: candRun.stepCount,
-            firstDivergenceStep,
-        };
-    });
-    return {
-        results,
-        allAgree: results.every((r) => r.agree),
-    };
-}
-// Single-machine runner: snapshots the tape after each step and returns the
-// final output, the snapshot list, and the step count.
-function runOnce(runnable, input, stepsLimit) {
-    const tapeBlock = runnable.getTapeBlock();
-    const tape = new Tape({
-        alphabet: tapeBlock.tapes[0].alphabet,
-        symbols: input.split(''),
-    });
-    tapeBlock.replaceTape(tape);
-    const machine = new TuringMachine({ tapeBlock });
-    const snapshots = [];
-    let stepCount = 0;
-    // Inside the for-of body, the tape reflects the state BEFORE the current
-    // step's command (i.e. AFTER the previous step's command — or initial for
-    // step 1). After the loop, the tape has had every command applied.
-    for (const _ of machine.runStepByStep({ initialState: runnable.state, stepsLimit })) {
-        snapshots.push(tape.symbols.join(''));
-        stepCount += 1;
-    }
-    snapshots.push(tape.symbols.join(''));
-    return {
-        finalOutput: tape.symbols.join('').trim(),
-        snapshots,
-        stepCount,
-    };
-}

package/dist/utilities/functions.js

@@ -1,13 +0,0 @@
-const uniquePredicate = (v, i, a) => a.indexOf(v) === i;
-const idKey = Symbol('idCurrentKey');
-const idWeakMapKey = Symbol('idWeakMapKey');
-function id(object) {
-    if (!id[idWeakMapKey].has(object)) {
-        id[idWeakMapKey].set(object, id[idKey]);
-        id[idKey] += 1;
-    }
-    return id[idWeakMapKey].get(object);
-}
-id[idKey] = 0;
-id[idWeakMapKey] = new WeakMap();
-export { id, uniquePredicate, };

package/dist/utilities/graph.js

@@ -1,127 +0,0 @@
-import { movements, symbolCommands } from '../classes/TapeCommand';
-const movementDescriptionToLabel = {
-    'move caret left command': 'L',
-    'move caret right command': 'R',
-    'do not move carer': 'S',
-};
-const symbolCommandDescriptionToLabel = {
-    'keep symbol command': '·',
-    'erase symbol command': '⌫',
-};
-// Reserved characters in the encoded pattern string:
-//   '*'  per-cell ifOtherSymbol (matches any symbol on that tape)
-//   '-'  the tape's blank symbol
-//   ','  separates per-tape cells inside one pattern
-//   '|'  separates alternative patterns
-//   '\\' escape prefix — to represent any of '*', '-', ',', '|', or '\\' as a
-//        *literal* alphabet symbol, prefix it with '\\' (e.g. '\\*' for literal '*').
-function escapeAlphabetSymbol(s) {
-    return s
-        .replace(/\\/g, '\\\\')
-        .replace(/\*/g, '\\*')
-        .replace(/-/g, '\\-')
-        .replace(/,/g, '\\,')
-        .replace(/\|/g, '\\|');
-}
-export function decodePatternDescription(description, alphabets) {
-    if (!description) {
-        return '?';
-    }
-    if (description === 'other symbol') {
-        return '*';
-    }
-    try {
-        const patternList = JSON.parse(description);
-        return patternList
-            .map((pattern) => pattern
-            .map((s, tapeIx) => {
-            if (s === null) {
-                return '*';
-            }
-            if (s === alphabets[tapeIx]?.[0]) {
-                return '-';
-            }
-            return escapeAlphabetSymbol(s);
-        })
-            .join(','))
-            .join('|');
-    }
-    catch {
-        return description;
-    }
-}
-export function decodeMovement(description) {
-    if (!description) {
-        return '?';
-    }
-    return movementDescriptionToLabel[description] ?? description;
-}
-export function splitUnescaped(s, sep) {
-    const parts = [];
-    let current = '';
-    let i = 0;
-    while (i < s.length) {
-        if (s[i] === '\\' && i + 1 < s.length) {
-            current += s[i + 1];
-            i += 2;
-        }
-        else if (s[i] === sep) {
-            parts.push(current);
-            current = '';
-            i += 1;
-        }
-        else {
-            current += s[i];
-            i += 1;
-        }
-    }
-    parts.push(current);
-    return parts;
-}
-export function parsePatternString(s, alphabets) {
-    if (s === '*') {
-        return null;
-    }
-    const alternatives = splitUnescaped(s, '|');
-    return alternatives.map((alt) => {
-        const cells = splitUnescaped(alt, ',');
-        return cells.map((cell, tapeIx) => {
-            if (cell === '*') {
-                return null;
-            }
-            if (cell === '-') {
-                return alphabets[tapeIx]?.[0] ?? cell;
-            }
-            return cell;
-        });
-    });
-}
-const movementLabelToSymbol = {
-    L: movements.left,
-    R: movements.right,
-    S: movements.stay,
-};
-export function parseMovementLabel(label) {
-    const m = movementLabelToSymbol[label];
-    if (!m) {
-        throw new Error(`unknown movement label: ${label}`);
-    }
-    return m;
-}
-export function parseWriteSymbolLabel(label) {
-    if (label === '·') {
-        return symbolCommands.keep;
-    }
-    if (label === '⌫') {
-        return symbolCommands.erase;
-    }
-    return label;
-}
-export function decodeWriteSymbol(symbol) {
-    if (typeof symbol === 'symbol') {
-        const description = symbol.description ?? '?';
-        return symbolCommandDescriptionToLabel[description] ?? description;
-    }
-    return symbol;
-}
-// Format converters (toMermaid / fromMermaid) live in ./graphFormats.