@turing-machine-js/machine 2.0.0-alpha.0 → 2.0.0-alpha.2

package/dist/classes/Alphabet.d.ts

@@ -0,0 +1,9 @@
+export default class Alphabet {
+    #private;
+    constructor(symbols: string[] | Alphabet);
+    get symbols(): string[];
+    get blankSymbol(): string;
+    has(symbol: string): boolean;
+    get(index: number): string;
+    index(symbol: string): number;
+}

package/dist/classes/Alphabet.js

@@ -0,0 +1,50 @@
+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 _Alphabet_symbols;
+import { uniquePredicate } from '../utilities/functions';
+class Alphabet {
+    constructor(symbols) {
+        _Alphabet_symbols.set(this, void 0);
+        if (symbols instanceof Alphabet) {
+            symbols = symbols.symbols;
+        }
+        const uniqueSymbols = symbols.filter(uniquePredicate);
+        if (uniqueSymbols.length < 2) {
+            throw new Error('Invalid symbols length');
+        }
+        const isSymbolsValid = uniqueSymbols.every((symbol) => symbol.length === 1);
+        if (!isSymbolsValid) {
+            throw new Error('symbols contains invalid symbol');
+        }
+        __classPrivateFieldSet(this, _Alphabet_symbols, Array.from(uniqueSymbols), "f");
+    }
+    get symbols() {
+        return Array.from(__classPrivateFieldGet(this, _Alphabet_symbols, "f"));
+    }
+    get blankSymbol() {
+        return __classPrivateFieldGet(this, _Alphabet_symbols, "f")[0];
+    }
+    has(symbol) {
+        return __classPrivateFieldGet(this, _Alphabet_symbols, "f").indexOf(symbol) >= 0;
+    }
+    get(index) {
+        if (index < 0 || index >= __classPrivateFieldGet(this, _Alphabet_symbols, "f").length) {
+            throw new Error('Invalid index');
+        }
+        return __classPrivateFieldGet(this, _Alphabet_symbols, "f")[index];
+    }
+    index(symbol) {
+        return __classPrivateFieldGet(this, _Alphabet_symbols, "f").indexOf(symbol);
+    }
+}
+_Alphabet_symbols = new WeakMap();
+export default Alphabet;

package/dist/classes/Command.d.ts

@@ -0,0 +1,6 @@
+import TapeCommand from './TapeCommand';
+export default class Command {
+    #private;
+    constructor(tapesCommands: TapeCommand[] | ConstructorParameters<typeof TapeCommand>[0][]);
+    get tapesCommands(): TapeCommand[];
+}

package/dist/classes/Command.js

@@ -0,0 +1,38 @@
+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 _Command_tapesCommands;
+import TapeCommand from './TapeCommand';
+class Command {
+    constructor(tapesCommands) {
+        _Command_tapesCommands.set(this, void 0);
+        if (tapesCommands.length === 0) {
+            throw new Error('invalid parameter');
+        }
+        try {
+            __classPrivateFieldSet(this, _Command_tapesCommands, tapesCommands.map((tapeCommand) => {
+                if (tapeCommand instanceof TapeCommand) {
+                    return tapeCommand;
+                }
+                return new TapeCommand(tapeCommand);
+            }), "f");
+        }
+        catch (error) {
+            void error;
+            throw new Error('invalid tapeCommand');
+        }
+    }
+    get tapesCommands() {
+        return [...__classPrivateFieldGet(this, _Command_tapesCommands, "f")];
+    }
+}
+_Command_tapesCommands = new WeakMap();
+export default Command;

package/dist/classes/Lock.d.ts

@@ -0,0 +1,6 @@
+export default class Lock {
+    #private;
+    lock(symbol: symbol): void;
+    unlock(symbol: symbol): void;
+    check(symbol: symbol | null): void;
+}

package/dist/classes/Lock.js

@@ -0,0 +1,34 @@
+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 __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 _Lock_lockSymbol;
+class Lock {
+    constructor() {
+        _Lock_lockSymbol.set(this, null);
+    }
+    lock(symbol) {
+        if (__classPrivateFieldGet(this, _Lock_lockSymbol, "f") === null) {
+            __classPrivateFieldSet(this, _Lock_lockSymbol, symbol, "f");
+        }
+    }
+    unlock(symbol) {
+        if (__classPrivateFieldGet(this, _Lock_lockSymbol, "f") === symbol) {
+            __classPrivateFieldSet(this, _Lock_lockSymbol, null, "f");
+        }
+    }
+    check(symbol) {
+        if (__classPrivateFieldGet(this, _Lock_lockSymbol, "f") && __classPrivateFieldGet(this, _Lock_lockSymbol, "f") !== symbol) {
+            throw new Error('Lock check failed');
+        }
+    }
+}
+_Lock_lockSymbol = new WeakMap();
+export default Lock;

package/dist/classes/Reference.d.ts

@@ -0,0 +1,6 @@
+import State from './State';
+export default class Reference {
+    #private;
+    get ref(): State;
+    bind(state: State): State;
+}

package/dist/classes/Reference.js

@@ -0,0 +1,31 @@
+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 __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 _Reference_referenceBinding;
+class Reference {
+    constructor() {
+        _Reference_referenceBinding.set(this, null);
+    }
+    get ref() {
+        if (!__classPrivateFieldGet(this, _Reference_referenceBinding, "f")) {
+            throw new Error('unbounded reference');
+        }
+        return __classPrivateFieldGet(this, _Reference_referenceBinding, "f");
+    }
+    bind(state) {
+        if (__classPrivateFieldGet(this, _Reference_referenceBinding, "f") == null) {
+            __classPrivateFieldSet(this, _Reference_referenceBinding, state, "f");
+        }
+        return __classPrivateFieldGet(this, _Reference_referenceBinding, "f");
+    }
+}
+_Reference_referenceBinding = new WeakMap();
+export default Reference;

package/dist/classes/State.d.ts

@@ -0,0 +1,22 @@
+import Command from './Command';
+import Reference from './Reference';
+import TapeBlock from './TapeBlock';
+import TapeCommand from './TapeCommand';
+export declare const ifOtherSymbol: unique symbol;
+export default class State {
+    #private;
+    constructor(stateDefinition?: Record<string | symbol, {
+        command?: Command | ConstructorParameters<typeof TapeCommand>[0] | ConstructorParameters<typeof TapeCommand>[0][];
+        nextState?: State | Reference;
+    }> | null, name?: string);
+    get id(): number;
+    get name(): string;
+    get isHalt(): boolean;
+    get overrodeHaltState(): State | null;
+    get ref(): this;
+    getSymbol(tapeBlock: TapeBlock): symbol;
+    getCommand(symbol: symbol): Command;
+    getNextState(symbol: symbol): State | Reference;
+    withOverrodeHaltState(overrodeHaltState: State): State;
+}
+export declare const haltState: State;

package/dist/classes/State.js

@@ -0,0 +1,113 @@
+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 __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 _State_id, _State_name, _State_overrodeHaltState, _State_symbolToDataMap;
+import Command from './Command';
+import Reference from './Reference';
+import TapeCommand from './TapeCommand';
+import { id } from '../utilities/functions';
+export const ifOtherSymbol = Symbol('other symbol');
+class State {
+    constructor(stateDefinition = null, name) {
+        _State_id.set(this, id(this));
+        _State_name.set(this, void 0);
+        _State_overrodeHaltState.set(this, null);
+        _State_symbolToDataMap.set(this, new Map());
+        if (stateDefinition) {
+            const keys = Object.getOwnPropertyNames(stateDefinition);
+            if (keys.length) {
+                throw new Error(`invalid state definition while constructing state #${__classPrivateFieldGet(this, _State_id, "f")}`);
+            }
+            const symbols = Object.getOwnPropertySymbols(stateDefinition);
+            if (symbols.length === 0) {
+                throw new Error(`invalid state definition while constructing state #${__classPrivateFieldGet(this, _State_id, "f")}`);
+            }
+            symbols.forEach((symbol) => {
+                const { nextState } = stateDefinition[symbol];
+                const nextStateLocal = nextState !== null && nextState !== void 0 ? nextState : this;
+                if (!(nextStateLocal instanceof State) && !(nextStateLocal instanceof Reference)) {
+                    throw new Error('invalid nextState');
+                }
+                let { command } = stateDefinition[symbol];
+                if (command == null) {
+                    command = new Command([
+                        new TapeCommand({}),
+                    ]);
+                }
+                if (!(command instanceof Command) && !Array.isArray(command)) {
+                    command = [command];
+                }
+                let commandLocal = command;
+                if (Array.isArray(command)) {
+                    try {
+                        commandLocal = new Command(command);
+                    }
+                    catch (error) {
+                        void error;
+                    }
+                }
+                if (!(commandLocal instanceof Command)) {
+                    throw new Error('invalid command');
+                }
+                __classPrivateFieldGet(this, _State_symbolToDataMap, "f").set(symbol, {
+                    command: commandLocal,
+                    nextState: nextStateLocal,
+                });
+            });
+        }
+        __classPrivateFieldSet(this, _State_name, name !== null && name !== void 0 ? name : `id:${__classPrivateFieldGet(this, _State_id, "f")}`, "f");
+    }
+    get id() {
+        return __classPrivateFieldGet(this, _State_id, "f");
+    }
+    get name() {
+        return __classPrivateFieldGet(this, _State_name, "f");
+    }
+    get isHalt() {
+        return __classPrivateFieldGet(this, _State_id, "f") === 0;
+    }
+    get overrodeHaltState() {
+        return __classPrivateFieldGet(this, _State_overrodeHaltState, "f");
+    }
+    get ref() {
+        return this;
+    }
+    getSymbol(tapeBlock) {
+        const symbol = [...__classPrivateFieldGet(this, _State_symbolToDataMap, "f").keys()].find((currentSymbol) => tapeBlock.isMatched({
+            symbol: currentSymbol,
+        }));
+        if (symbol) {
+            return symbol;
+        }
+        return ifOtherSymbol;
+    }
+    getCommand(symbol) {
+        if (__classPrivateFieldGet(this, _State_symbolToDataMap, "f").has(symbol)) {
+            return __classPrivateFieldGet(this, _State_symbolToDataMap, "f").get(symbol).command;
+        }
+        throw new Error(`No command for symbol at state named ${__classPrivateFieldGet(this, _State_name, "f")}`);
+    }
+    getNextState(symbol) {
+        if (__classPrivateFieldGet(this, _State_symbolToDataMap, "f").has(symbol)) {
+            return __classPrivateFieldGet(this, _State_symbolToDataMap, "f").get(symbol).nextState;
+        }
+        throw new Error(`No nextState for symbol at state named ${__classPrivateFieldGet(this, _State_id, "f")}`);
+    }
+    withOverrodeHaltState(overrodeHaltState) {
+        const state = new State(null, `${this.name}>${overrodeHaltState.name}`);
+        __classPrivateFieldSet(state, _State_symbolToDataMap, __classPrivateFieldGet(this, _State_symbolToDataMap, "f"), "f");
+        __classPrivateFieldSet(state, _State_overrodeHaltState, overrodeHaltState, "f");
+        return state;
+    }
+}
+_State_id = new WeakMap(), _State_name = new WeakMap(), _State_overrodeHaltState = new WeakMap(), _State_symbolToDataMap = new WeakMap();
+export default State;
+export const haltState = new State(null);

package/dist/classes/Tape.d.ts

@@ -0,0 +1,24 @@
+import Alphabet from './Alphabet';
+type TapeConstructorParameter = {
+    alphabet: Alphabet;
+    symbols?: string[];
+    position?: number;
+    viewportWidth?: number;
+};
+export default class Tape {
+    #private;
+    constructor({ alphabet, symbols, position, viewportWidth, }: TapeConstructorParameter);
+    get alphabet(): Alphabet;
+    get extraCellsCount(): number;
+    get position(): number;
+    get symbol(): string;
+    set symbol(symbol: string);
+    get symbols(): string[];
+    get viewport(): string[];
+    get viewportWidth(): number;
+    set viewportWidth(width: number);
+    left(): void;
+    normalise(): void;
+    right(): void;
+}
+export {};

package/dist/classes/Tape.js

@@ -0,0 +1,95 @@
+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.d.ts

@@ -0,0 +1,28 @@
+import Alphabet from './Alphabet';
+import Command from './Command';
+import Tape from './Tape';
+import Lock from './Lock';
+declare const symbolToPatternListMapSymbol: unique symbol;
+export declare const lockSymbol: unique symbol;
+type PatternList = (string | symbol)[][];
+type SymbolToPatternListMap = Map<symbol, PatternList>;
+export default class TapeBlock {
+    #private;
+    private constructor();
+    get alphabets(): Alphabet[];
+    get currentSymbols(): string[];
+    get [lockSymbol](): Lock;
+    get symbol(): (symbols: (symbol | string)[] | symbol | string) => symbol;
+    get tapes(): Tape[];
+    set [symbolToPatternListMapSymbol](symbolToPatternListMap: SymbolToPatternListMap);
+    static fromAlphabets: (alphabets: Alphabet[]) => TapeBlock;
+    static fromTapes: (tapes: Tape[]) => TapeBlock;
+    applyCommand(command: Command, executionSymbol?: symbol | null): void;
+    clone(cloneTapes?: boolean): TapeBlock;
+    isMatched({ currentSymbols, symbol }: {
+        currentSymbols?: string[];
+        symbol: symbol;
+    }): boolean;
+    replaceTape(tape: Tape, tapeIx?: number): void;
+}
+export {};

package/dist/classes/TapeBlock.js

@@ -0,0 +1,198 @@
+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 }) {
+        var _b;
+        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 (_b = patternList === null || patternList === void 0 ? void 0 : patternList.some((pattern) => (pattern
+            .every((everySymbol, ix) => (everySymbol === ifOtherSymbol
+            || everySymbol === currentSymbols[ix]))))) !== null && _b !== void 0 ? _b : 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.d.ts

@@ -0,0 +1,20 @@
+export declare const movements: {
+    left: symbol;
+    right: symbol;
+    stay: symbol;
+};
+export declare const symbolCommands: {
+    erase: symbol;
+    keep: symbol;
+};
+type TapeCommandConstructorParam = {
+    movement?: symbol;
+    symbol?: string | symbol;
+};
+export default class TapeCommand {
+    #private;
+    constructor({ movement, symbol, }: TapeCommandConstructorParam);
+    get symbol(): string | symbol;
+    get movement(): symbol;
+}
+export {};

package/dist/classes/TapeCommand.js

@@ -0,0 +1,46 @@
+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.d.ts

@@ -0,0 +1,26 @@
+import State from './State';
+import TapeBlock from './TapeBlock';
+type RunParameter = {
+    initialState: State;
+    stepsLimit?: number;
+};
+export type MachineState = {
+    step: number;
+    state: State;
+    currentSymbols: string[];
+    nextSymbols: string[];
+    movements: symbol[];
+    nextState: State;
+};
+export default class TuringMachine {
+    #private;
+    constructor({ tapeBlock, }?: {
+        tapeBlock?: TapeBlock;
+    });
+    get tapeBlock(): TapeBlock;
+    run({ initialState, stepsLimit, onStep }: RunParameter & {
+        onStep?: (machineState: MachineState) => void;
+    }): void;
+    runStepByStep({ initialState, stepsLimit }: RunParameter): Generator<MachineState>;
+}
+export {};

package/dist/classes/TuringMachine.js

@@ -0,0 +1,102 @@
+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.d.ts

@@ -0,0 +1,8 @@
+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';

package/dist/index.js

@@ -0,0 +1,8 @@
+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';

package/dist/utilities/functions.d.ts

@@ -0,0 +1,4 @@
+declare const uniquePredicate: <T>(v: T, i: number, a: T[]) => boolean;
+declare function id(object: object): number;
+declare namespace id { }
+export { id, uniquePredicate, };

package/dist/utilities/functions.js

@@ -0,0 +1,13 @@
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turing-machine-js/machine",
-  "version": "2.0.0-alpha.0",
+  "version": "2.0.0-alpha.2",
   "description": "A convenient Turing machine",
   "author": "Ruslan Gilmullin <mellonis14@gmain.com>",
   "homepage": "https://github.com/mellonis/turing-machine-js#readme",
@@ -21,5 +21,5 @@
     "machine"
   ],
   "module": "dist/index.js",
-  "gitHead": "eac8ba0029090bdbd64f72566657400101fd587e"
+  "gitHead": "5f0e4eaf5c2671438590a479261481ad4bec58bd"
 }