@turing-machine-js/machine 2.0.0 → 2.0.2

package/dist/index.mjs

@@ -0,0 +1,705 @@
+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();
+
+var __classPrivateFieldSet$8 = (undefined && undefined.__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$8 = (undefined && undefined.__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;
+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$8(this, _Alphabet_symbols, Array.from(uniqueSymbols), "f");
+    }
+    get symbols() {
+        return Array.from(__classPrivateFieldGet$8(this, _Alphabet_symbols, "f"));
+    }
+    get blankSymbol() {
+        return __classPrivateFieldGet$8(this, _Alphabet_symbols, "f")[0];
+    }
+    has(symbol) {
+        return __classPrivateFieldGet$8(this, _Alphabet_symbols, "f").indexOf(symbol) >= 0;
+    }
+    get(index) {
+        if (index < 0 || index >= __classPrivateFieldGet$8(this, _Alphabet_symbols, "f").length) {
+            throw new Error('Invalid index');
+        }
+        return __classPrivateFieldGet$8(this, _Alphabet_symbols, "f")[index];
+    }
+    index(symbol) {
+        return __classPrivateFieldGet$8(this, _Alphabet_symbols, "f").indexOf(symbol);
+    }
+}
+_Alphabet_symbols = new WeakMap();
+
+var __classPrivateFieldSet$7 = (undefined && undefined.__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$7 = (undefined && undefined.__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;
+const movements = {
+    left: Symbol('move caret left command'),
+    right: Symbol('move caret right command'),
+    stay: Symbol('do not move carer'),
+};
+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$7(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$7(this, _TapeCommand_symbol, symbol, "f");
+    }
+    get symbol() {
+        return __classPrivateFieldGet$7(this, _TapeCommand_symbol, "f");
+    }
+    get movement() {
+        return __classPrivateFieldGet$7(this, _TapeCommand_movement, "f");
+    }
+}
+_TapeCommand_movement = new WeakMap(), _TapeCommand_symbol = new WeakMap();
+
+var __classPrivateFieldSet$6 = (undefined && undefined.__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$6 = (undefined && undefined.__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;
+class Command {
+    constructor(tapesCommands) {
+        _Command_tapesCommands.set(this, void 0);
+        if (tapesCommands.length === 0) {
+            throw new Error('invalid parameter');
+        }
+        try {
+            __classPrivateFieldSet$6(this, _Command_tapesCommands, tapesCommands.map((tapeCommand) => {
+                if (tapeCommand instanceof TapeCommand) {
+                    return tapeCommand;
+                }
+                return new TapeCommand(tapeCommand);
+            }), "f");
+        }
+        catch (error) {
+            throw new Error('invalid tapeCommand');
+        }
+    }
+    get tapesCommands() {
+        return [...__classPrivateFieldGet$6(this, _Command_tapesCommands, "f")];
+    }
+}
+_Command_tapesCommands = new WeakMap();
+
+var __classPrivateFieldGet$5 = (undefined && undefined.__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$5 = (undefined && undefined.__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$5(this, _Reference_referenceBinding, "f")) {
+            throw new Error('unbounded reference');
+        }
+        return __classPrivateFieldGet$5(this, _Reference_referenceBinding, "f");
+    }
+    bind(state) {
+        if (__classPrivateFieldGet$5(this, _Reference_referenceBinding, "f") == null) {
+            __classPrivateFieldSet$5(this, _Reference_referenceBinding, state, "f");
+        }
+        return __classPrivateFieldGet$5(this, _Reference_referenceBinding, "f");
+    }
+}
+_Reference_referenceBinding = new WeakMap();
+
+var __classPrivateFieldGet$4 = (undefined && undefined.__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$4 = (undefined && undefined.__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;
+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$4(this, _State_id, "f")}`);
+            }
+            const symbols = Object.getOwnPropertySymbols(stateDefinition);
+            if (symbols.length === 0) {
+                throw new Error(`invalid state definition while constructing state #${__classPrivateFieldGet$4(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) {
+                    }
+                }
+                if (!(commandLocal instanceof Command)) {
+                    throw new Error('invalid command');
+                }
+                __classPrivateFieldGet$4(this, _State_symbolToDataMap, "f").set(symbol, {
+                    command: commandLocal,
+                    nextState: nextStateLocal,
+                });
+            });
+        }
+        __classPrivateFieldSet$4(this, _State_name, name !== null && name !== void 0 ? name : `id:${__classPrivateFieldGet$4(this, _State_id, "f")}`, "f");
+    }
+    get id() {
+        return __classPrivateFieldGet$4(this, _State_id, "f");
+    }
+    get name() {
+        return __classPrivateFieldGet$4(this, _State_name, "f");
+    }
+    get isHalt() {
+        return __classPrivateFieldGet$4(this, _State_id, "f") === 0;
+    }
+    get overrodeHaltState() {
+        return __classPrivateFieldGet$4(this, _State_overrodeHaltState, "f");
+    }
+    get ref() {
+        return this;
+    }
+    getSymbol(tapeBlock) {
+        const symbol = [...__classPrivateFieldGet$4(this, _State_symbolToDataMap, "f").keys()].find((currentSymbol) => tapeBlock.isMatched({
+            symbol: currentSymbol,
+        }));
+        if (symbol) {
+            return symbol;
+        }
+        return ifOtherSymbol;
+    }
+    getCommand(symbol) {
+        if (__classPrivateFieldGet$4(this, _State_symbolToDataMap, "f").has(symbol)) {
+            return __classPrivateFieldGet$4(this, _State_symbolToDataMap, "f").get(symbol).command;
+        }
+        throw new Error(`No command for symbol at state named ${__classPrivateFieldGet$4(this, _State_name, "f")}`);
+    }
+    getNextState(symbol) {
+        if (__classPrivateFieldGet$4(this, _State_symbolToDataMap, "f").has(symbol)) {
+            return __classPrivateFieldGet$4(this, _State_symbolToDataMap, "f").get(symbol).nextState;
+        }
+        throw new Error(`No nextState for symbol at state named ${__classPrivateFieldGet$4(this, _State_id, "f")}`);
+    }
+    withOverrodeHaltState(overrodeHaltState) {
+        const state = new State(null, `${this.name}>${overrodeHaltState.name}`);
+        __classPrivateFieldSet$4(state, _State_symbolToDataMap, __classPrivateFieldGet$4(this, _State_symbolToDataMap, "f"), "f");
+        __classPrivateFieldSet$4(state, _State_overrodeHaltState, overrodeHaltState, "f");
+        return state;
+    }
+}
+_State_id = new WeakMap(), _State_name = new WeakMap(), _State_overrodeHaltState = new WeakMap(), _State_symbolToDataMap = new WeakMap();
+const haltState = new State(null);
+
+var __classPrivateFieldSet$3 = (undefined && undefined.__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$3 = (undefined && undefined.__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;
+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$3(this, _Tape_alphabet, new Alphabet(alphabet), "f");
+        __classPrivateFieldSet$3(this, _Tape_position, position, "f");
+        __classPrivateFieldSet$3(this, _Tape_viewportWidth, viewportWidth, "f");
+        const symbolsCopy = Array.from(symbols);
+        if (symbolsCopy.length === 0) {
+            symbolsCopy.push(__classPrivateFieldGet$3(this, _Tape_alphabet, "f").blankSymbol);
+        }
+        __classPrivateFieldSet$3(this, _Tape_symbols, symbolsCopy.map((symbol) => __classPrivateFieldGet$3(this, _Tape_alphabet, "f").index(symbol)), "f");
+    }
+    get alphabet() {
+        return __classPrivateFieldGet$3(this, _Tape_alphabet, "f");
+    }
+    get extraCellsCount() {
+        return (__classPrivateFieldGet$3(this, _Tape_viewportWidth, "f") - 1) / 2;
+    }
+    get position() {
+        return __classPrivateFieldGet$3(this, _Tape_position, "f");
+    }
+    get symbol() {
+        return __classPrivateFieldGet$3(this, _Tape_alphabet, "f").get(__classPrivateFieldGet$3(this, _Tape_symbols, "f")[__classPrivateFieldGet$3(this, _Tape_position, "f")]);
+    }
+    set symbol(symbol) {
+        if (!__classPrivateFieldGet$3(this, _Tape_alphabet, "f").has(symbol)) {
+            throw new Error('Invalid symbol');
+        }
+        __classPrivateFieldGet$3(this, _Tape_symbols, "f")[__classPrivateFieldGet$3(this, _Tape_position, "f")] = __classPrivateFieldGet$3(this, _Tape_alphabet, "f").index(symbol);
+    }
+    get symbols() {
+        return __classPrivateFieldGet$3(this, _Tape_symbols, "f")
+            .map((index) => __classPrivateFieldGet$3(this, _Tape_alphabet, "f").get(index));
+    }
+    get viewport() {
+        const startIx = __classPrivateFieldGet$3(this, _Tape_position, "f") - this.extraCellsCount;
+        const endIx = __classPrivateFieldGet$3(this, _Tape_position, "f") + this.extraCellsCount + 1;
+        return __classPrivateFieldGet$3(this, _Tape_symbols, "f")
+            .slice(startIx, endIx)
+            .map((index) => __classPrivateFieldGet$3(this, _Tape_alphabet, "f").get(index));
+    }
+    get viewportWidth() {
+        return __classPrivateFieldGet$3(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$3(this, _Tape_viewportWidth, finalWidth, "f");
+        this.normalise();
+    }
+    left() {
+        __classPrivateFieldSet$3(this, _Tape_position, __classPrivateFieldGet$3(this, _Tape_position, "f") - 1, "f");
+        this.normalise();
+    }
+    normalise() {
+        while (__classPrivateFieldGet$3(this, _Tape_position, "f") - this.extraCellsCount < 0) {
+            __classPrivateFieldGet$3(this, _Tape_symbols, "f").unshift(0);
+            __classPrivateFieldSet$3(this, _Tape_position, __classPrivateFieldGet$3(this, _Tape_position, "f") + 1, "f");
+        }
+        while (__classPrivateFieldGet$3(this, _Tape_position, "f") + this.extraCellsCount >= __classPrivateFieldGet$3(this, _Tape_symbols, "f").length) {
+            __classPrivateFieldGet$3(this, _Tape_symbols, "f").push(0);
+        }
+    }
+    right() {
+        __classPrivateFieldSet$3(this, _Tape_position, __classPrivateFieldGet$3(this, _Tape_position, "f") + 1, "f");
+        this.normalise();
+    }
+}
+_Tape_alphabet = new WeakMap(), _Tape_symbols = new WeakMap(), _Tape_position = new WeakMap(), _Tape_viewportWidth = new WeakMap();
+
+var __classPrivateFieldGet$2 = (undefined && undefined.__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$2 = (undefined && undefined.__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$2(this, _Lock_lockSymbol, "f") === null) {
+            __classPrivateFieldSet$2(this, _Lock_lockSymbol, symbol, "f");
+        }
+    }
+    unlock(symbol) {
+        if (__classPrivateFieldGet$2(this, _Lock_lockSymbol, "f") === symbol) {
+            __classPrivateFieldSet$2(this, _Lock_lockSymbol, null, "f");
+        }
+    }
+    check(symbol) {
+        if (__classPrivateFieldGet$2(this, _Lock_lockSymbol, "f") && __classPrivateFieldGet$2(this, _Lock_lockSymbol, "f") !== symbol) {
+            throw new Error('Lock check failed');
+        }
+    }
+}
+_Lock_lockSymbol = new WeakMap();
+
+var __classPrivateFieldSet$1 = (undefined && undefined.__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$1 = (undefined && undefined.__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;
+const symbolToPatternListMapSymbol = Symbol('symbol for symbolToPatternListMap setter');
+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$1(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$1(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$1(_a, _a, "f", _TapeBlock_generateSymbolHint).call(_a, patternList));
+                __classPrivateFieldGet$1(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$1(this, _TapeBlock_tapes, "f").length > 0) {
+                throw new Error('invalid symbol parameter');
+            }
+            const invalidSymbolIndex = localSymbols.findIndex((symbol, ix) => (symbol !== ifOtherSymbol
+                && !__classPrivateFieldGet$1(this, _TapeBlock_tapes, "f")[ix % __classPrivateFieldGet$1(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$1(this, _TapeBlock_getSymbolForPatternList, "f").call(this, __classPrivateFieldGet$1(this, _TapeBlock_buildPatternList, "f").call(this, localSymbols));
+        });
+        __classPrivateFieldSet$1(this, _TapeBlock_tapes, [], "f");
+        if ('alphabets' in argument) {
+            const { alphabets } = argument;
+            if (alphabets.length === 0) {
+                throw new Error('empty alphabet list');
+            }
+            __classPrivateFieldSet$1(this, _TapeBlock_tapes, alphabets.map((alphabet) => new Tape({
+                alphabet,
+            })), "f");
+        }
+        else if ('tapes' in argument) {
+            __classPrivateFieldSet$1(this, _TapeBlock_tapes, argument.tapes, "f");
+        }
+        if (__classPrivateFieldGet$1(this, _TapeBlock_tapes, "f").length === 0) {
+            throw new Error('empty tape list');
+        }
+    }
+    get alphabets() {
+        return [...__classPrivateFieldGet$1(this, _TapeBlock_tapes, "f").map((tape) => tape.alphabet)];
+    }
+    get currentSymbols() {
+        return __classPrivateFieldGet$1(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$1(this, _TapeBlock_lock, "f");
+    }
+    get symbol() {
+        return __classPrivateFieldGet$1(this, _TapeBlock_symbol, "f").bind(this);
+    }
+    get tapes() {
+        return [...__classPrivateFieldGet$1(this, _TapeBlock_tapes, "f")];
+    }
+    set [symbolToPatternListMapSymbol](symbolToPatternListMap) {
+        __classPrivateFieldSet$1(this, _TapeBlock_symbolToPatternListMap, new Map(symbolToPatternListMap), "f");
+    }
+    applyCommand(command, executionSymbol = null) {
+        __classPrivateFieldGet$1(this, _TapeBlock_lock, "f").check(executionSymbol);
+        if (__classPrivateFieldGet$1(this, _TapeBlock_tapes, "f").length !== command.tapesCommands.length) {
+            throw new Error('invalid command');
+        }
+        __classPrivateFieldGet$1(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$1(this, _TapeBlock_symbolToPatternListMap, "f");
+        return tapeBlock;
+    }
+    isMatched({ currentSymbols = this.currentSymbols, symbol }) {
+        var _b;
+        if (symbol === ifOtherSymbol) {
+            return true;
+        }
+        if (!__classPrivateFieldGet$1(this, _TapeBlock_symbolToPatternListMap, "f").has(symbol)) {
+            throw new Error('invalid symbol');
+        }
+        const patternList = __classPrivateFieldGet$1(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$1(this, _TapeBlock_tapes, "f")[tapeIx] == null) {
+            throw new Error('invalid tapeIx');
+        }
+        if (tape.alphabet.symbols.join('') === __classPrivateFieldGet$1(this, _TapeBlock_tapes, "f")[tapeIx].alphabet.symbols.join('')) {
+            __classPrivateFieldGet$1(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)))) };
+
+var __classPrivateFieldSet = (undefined && undefined.__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 = (undefined && undefined.__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;
+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 { Alphabet, Command, Reference, State, Tape, TapeBlock, TapeCommand, TuringMachine, haltState, ifOtherSymbol, movements, symbolCommands };