@vsirotin/ts-stop 1.13.0 → 2.4.1

package/lib/IStateWithActions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"IStateWithActions.js","sourceRoot":"","sources":["../src/IStateWithActions.ts"],"names":[],"mappings":""}

package/lib/IStateWithOutputSignal.d.ts

@@ -1,4 +0,0 @@
-export interface IStateWithOutputSignal<SIGNAL> {
-    getOutputSignal(): SIGNAL;
-}
-//# sourceMappingURL=IStateWithOutputSignal.d.ts.map

package/lib/IStateWithOutputSignal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IStateWithOutputSignal.d.ts","sourceRoot":"","sources":["../src/IStateWithOutputSignal.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,sBAAsB,CAAC,MAAM;IAC1C,eAAe,IAAI,MAAM,CAAC;CAC7B"}

package/lib/IStateWithOutputSignal.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=IStateWithOutputSignal.js.map

package/lib/IStateWithOutputSignal.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"IStateWithOutputSignal.js","sourceRoot":"","sources":["../src/IStateWithOutputSignal.ts"],"names":[],"mappings":""}

package/lib/MatrixBasedStateMachine.d.ts

@@ -1,108 +0,0 @@
-import { FiniteStateMachine } from './FiniteStateMachine';
-import { TransitionMatrix } from './TransitionMatrix';
-/**
- * Abstract base class for finite state machines that use transition matrices.
- *
- * This class extends FiniteStateMachine to provide a more intuitive way to define
- * state transitions using a 2D matrix representation instead of explicit transition arrays.
- *
- * The matrix format allows for visual representation of state transitions:
- * - Columns represent states
- * - Rows represent signals
- * - Cell values represent target states
- * - Empty cells represent invalid/ignored transitions
- *
- * @template STATE - The type representing possible states
- * @template SIGNAL - The type representing signals/events
- *
- * @example
- * ```typescript
- * // Example 1: Using explicit start state
- * class TurnstileMatrix extends MatrixBasedStateMachine<string, string> {
- *     constructor() {
- *         const matrix = transitionMatrix([
- *             [           , "locked"    , "unlocked" ],
- *             [ "coin"    , "unlocked" ,             ],
- *             [ "push"    ,            , "locked"   ]
- *         ]);
- *         super(matrix, "locked"); // Explicit start state
- *     }
- * }
- *
- * // Example 2: Using first state as start state (auto)
- * class TurnstileMatrixAuto extends MatrixBasedStateMachine<string, string> {
- *     constructor() {
- *         const matrix = transitionMatrix([
- *             [           , "locked"    , "unlocked" ],  // "locked" becomes start state
- *             [ "coin"    , "unlocked" ,             ],
- *             [ "push"    ,            , "locked"   ]
- *         ]);
- *         super(matrix); // Uses first state ("locked") as start state
- *     }
- * }
- * ```
- */
-export declare abstract class MatrixBasedStateMachine<STATE, SIGNAL> extends FiniteStateMachine<STATE, SIGNAL> {
-    /**
-     * The transition matrix used to define state transitions.
-     * Stored for potential debugging or inspection purposes.
-     */
-    protected readonly matrix: TransitionMatrix<STATE, SIGNAL>;
-    /**
-     * Creates a new matrix-based finite state machine.
-     *
-     * @param matrix - The transition matrix defining all states, signals, and transitions
-     * @param startState - Optional. The initial state of the machine. If not provided,
-     *                     the first state from the matrix (first column in header row) will be used.
-     *                     If provided, must be one of the states in the matrix.
-     *
-     * @throws {Error} If matrix has no states
-     * @throws {Error} If startState is provided but not found in the matrix states
-     *
-     * @example
-     * ```typescript
-     * // Constructor with explicit start state
-     * const matrix = transitionMatrix([
-     *     [           , "locked"    , "unlocked" ],
-     *     [ "coin"    , "unlocked" ,             ],
-     *     [ "push"    ,            , "locked"   ]
-     * ]);
-     * super(matrix, "unlocked"); // Start in unlocked state
-     *
-     * // Constructor with auto start state (uses first state)
-     * super(matrix); // Automatically starts in "locked" state
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // TurnstileMatrix implementation from test/Turnstile/TurnstileMatrix.ts
-     * class TurnstileMatrix extends MatrixBasedStateMachine<string, string> {
-     *     constructor() {
-     *         const matrix = transitionMatrix([
-     *             [           , "locked"    , "unlocked" ],
-     *             [ "coin"    , "unlocked" ,             ],
-     *             [ "push"    ,            , "locked"   ]
-     *         ]);
-     *
-     *         // Two ways to call the constructor:
-     *         super(matrix, "locked");  // Option 1: Explicit start state
-     *         // OR
-     *         super(matrix);            // Option 2: Auto start state (uses "locked")
-     *     }
-     *
-     *     insertCoin(): string { return this.sendSignal('coin'); }
-     *     pushThrough(): string { return this.sendSignal('push'); }
-     *     isLocked(): boolean { return this.getCurrentState() === 'locked'; }
-     *     isUnlocked(): boolean { return this.getCurrentState() === 'unlocked'; }
-     * }
-     * ```
-     */
-    constructor(matrix: TransitionMatrix<STATE, SIGNAL>, startState?: STATE);
-    /**
-     * Gets the transition matrix used by this state machine.
-     *
-     * @returns The transition matrix
-     */
-    getMatrix(): TransitionMatrix<STATE, SIGNAL>;
-}
-//# sourceMappingURL=MatrixBasedStateMachine.d.ts.map

package/lib/MatrixBasedStateMachine.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MatrixBasedStateMachine.d.ts","sourceRoot":"","sources":["../src/MatrixBasedStateMachine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAuB,MAAM,sBAAsB,CAAC;AAC/E,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,8BAAsB,uBAAuB,CAAC,KAAK,EAAE,MAAM,CAAE,SAAQ,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC;IAClG;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgDG;gBACS,MAAM,EAAE,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,UAAU,CAAC,EAAE,KAAK;IAqCvE;;;;OAIG;IACH,SAAS,IAAI,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAAC;CAI/C"}

package/lib/MatrixBasedStateMachine.js

@@ -1,132 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MatrixBasedStateMachine = void 0;
-const FiniteStateMachine_1 = require("./FiniteStateMachine");
-/**
- * Abstract base class for finite state machines that use transition matrices.
- *
- * This class extends FiniteStateMachine to provide a more intuitive way to define
- * state transitions using a 2D matrix representation instead of explicit transition arrays.
- *
- * The matrix format allows for visual representation of state transitions:
- * - Columns represent states
- * - Rows represent signals
- * - Cell values represent target states
- * - Empty cells represent invalid/ignored transitions
- *
- * @template STATE - The type representing possible states
- * @template SIGNAL - The type representing signals/events
- *
- * @example
- * ```typescript
- * // Example 1: Using explicit start state
- * class TurnstileMatrix extends MatrixBasedStateMachine<string, string> {
- *     constructor() {
- *         const matrix = transitionMatrix([
- *             [           , "locked"    , "unlocked" ],
- *             [ "coin"    , "unlocked" ,             ],
- *             [ "push"    ,            , "locked"   ]
- *         ]);
- *         super(matrix, "locked"); // Explicit start state
- *     }
- * }
- *
- * // Example 2: Using first state as start state (auto)
- * class TurnstileMatrixAuto extends MatrixBasedStateMachine<string, string> {
- *     constructor() {
- *         const matrix = transitionMatrix([
- *             [           , "locked"    , "unlocked" ],  // "locked" becomes start state
- *             [ "coin"    , "unlocked" ,             ],
- *             [ "push"    ,            , "locked"   ]
- *         ]);
- *         super(matrix); // Uses first state ("locked") as start state
- *     }
- * }
- * ```
- */
-class MatrixBasedStateMachine extends FiniteStateMachine_1.FiniteStateMachine {
-    /**
-     * Creates a new matrix-based finite state machine.
-     *
-     * @param matrix - The transition matrix defining all states, signals, and transitions
-     * @param startState - Optional. The initial state of the machine. If not provided,
-     *                     the first state from the matrix (first column in header row) will be used.
-     *                     If provided, must be one of the states in the matrix.
-     *
-     * @throws {Error} If matrix has no states
-     * @throws {Error} If startState is provided but not found in the matrix states
-     *
-     * @example
-     * ```typescript
-     * // Constructor with explicit start state
-     * const matrix = transitionMatrix([
-     *     [           , "locked"    , "unlocked" ],
-     *     [ "coin"    , "unlocked" ,             ],
-     *     [ "push"    ,            , "locked"   ]
-     * ]);
-     * super(matrix, "unlocked"); // Start in unlocked state
-     *
-     * // Constructor with auto start state (uses first state)
-     * super(matrix); // Automatically starts in "locked" state
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // TurnstileMatrix implementation from test/Turnstile/TurnstileMatrix.ts
-     * class TurnstileMatrix extends MatrixBasedStateMachine<string, string> {
-     *     constructor() {
-     *         const matrix = transitionMatrix([
-     *             [           , "locked"    , "unlocked" ],
-     *             [ "coin"    , "unlocked" ,             ],
-     *             [ "push"    ,            , "locked"   ]
-     *         ]);
-     *
-     *         // Two ways to call the constructor:
-     *         super(matrix, "locked");  // Option 1: Explicit start state
-     *         // OR
-     *         super(matrix);            // Option 2: Auto start state (uses "locked")
-     *     }
-     *
-     *     insertCoin(): string { return this.sendSignal('coin'); }
-     *     pushThrough(): string { return this.sendSignal('push'); }
-     *     isLocked(): boolean { return this.getCurrentState() === 'locked'; }
-     *     isUnlocked(): boolean { return this.getCurrentState() === 'unlocked'; }
-     * }
-     * ```
-     */
-    constructor(matrix, startState) {
-        // Get states from matrix
-        const states = matrix.getStates();
-        // Validate matrix has states
-        if (states.length === 0) {
-            throw new Error('Matrix must contain at least one state');
-        }
-        // Determine the actual start state
-        let actualStartState;
-        if (startState !== undefined) {
-            // Explicit start state provided - validate it exists
-            if (!states.includes(startState)) {
-                throw new Error(`Start state '${String(startState)}' not found in matrix states: [${states.map(s => String(s)).join(', ')}]`);
-            }
-            actualStartState = startState;
-        }
-        else {
-            // No start state provided - use first state from matrix
-            actualStartState = states[0];
-        }
-        // Call parent constructor with matrix-derived data
-        super(matrix.getStates(), matrix.getSignals(), matrix.getTransitions(), actualStartState);
-        // Store the matrix for potential future use
-        this.matrix = matrix;
-    }
-    /**
-     * Gets the transition matrix used by this state machine.
-     *
-     * @returns The transition matrix
-     */
-    getMatrix() {
-        return this.matrix;
-    }
-}
-exports.MatrixBasedStateMachine = MatrixBasedStateMachine;
-//# sourceMappingURL=MatrixBasedStateMachine.js.map

package/lib/MatrixBasedStateMachine.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"MatrixBasedStateMachine.js","sourceRoot":"","sources":["../src/MatrixBasedStateMachine.ts"],"names":[],"mappings":";;;AAAA,6DAA+E;AAG/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,MAAsB,uBAAuC,SAAQ,uCAAiC;IAOlG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgDG;IACH,YAAY,MAAuC,EAAE,UAAkB;QACnE,yBAAyB;QACzB,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,EAAE,CAAC;QAElC,6BAA6B;QAC7B,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACtB,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;QAC9D,CAAC;QAED,mCAAmC;QACnC,IAAI,gBAAuB,CAAC;QAE5B,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;YAC3B,qDAAqD;YACrD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;gBAC/B,MAAM,IAAI,KAAK,CACX,gBAAgB,MAAM,CAAC,UAAU,CAAC,kCAAkC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAC/G,CAAC;YACN,CAAC;YACD,gBAAgB,GAAG,UAAU,CAAC;QAClC,CAAC;aAAM,CAAC;YACJ,wDAAwD;YACxD,gBAAgB,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QACjC,CAAC;QAED,mDAAmD;QACnD,KAAK,CACD,MAAM,CAAC,SAAS,EAAE,EAClB,MAAM,CAAC,UAAU,EAAE,EACnB,MAAM,CAAC,cAAc,EAAE,EACvB,gBAAgB,CACnB,CAAC;QAEF,4CAA4C;QAC5C,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACH,SAAS;QACL,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;CAEJ;AAtGD,0DAsGC"}

package/lib/TransitionMatrix.d.ts

@@ -1,61 +0,0 @@
-/**
- * Utility type to extract non-empty values from transition matrix
- */
-export type NonEmpty<T> = T extends "" | undefined | null ? never : T;
-/**
- * Creates transitions from a 2D matrix representation.
- *
- * Matrix format:
- * - First row: [undefined, ...states] - column headers
- * - Subsequent rows: [signal, ...transitions] - signal + target states
- * - Empty cells: undefined, null, "", or omitted
- *
- * @template STATE - Type for states
- * @template SIGNAL - Type for signals
- */
-export declare class TransitionMatrix<STATE, SIGNAL> {
-    private states;
-    private signals;
-    private transitions;
-    /**
-     * Creates a transition matrix from a 2D array.
-     *
-     * @param matrix - 2D array where:
-     *   - matrix[0] = [undefined, ...states] (header row)
-     *   - matrix[i] = [signal, target1, target2, ...] (transition rows)
-     *
-     * @example
-     * ```typescript
-     * const matrix = [
-     *     [           , "locked"    , "unlocked" ],  // States header
-     *     [ "coin"    , "unlocked" ,             ],  // coin transitions
-     *     [ "push"    ,            , "locked"   ]   // push transitions
-     * ];
-     * ```
-     */
-    static fromArray<S, G>(matrix: Array<Array<S | G | undefined | null | "">>): TransitionMatrix<NonEmpty<S>, NonEmpty<G>>;
-    /**
-     * Get all states from the matrix.
-     */
-    getStates(): STATE[];
-    /**
-     * Get all signals from the matrix.
-     */
-    getSignals(): SIGNAL[];
-    /**
-     * Get all transitions from the matrix.
-     */
-    getTransitions(): {
-        from: STATE;
-        to: STATE;
-        signal: SIGNAL;
-    }[];
-}
-/**
- * Helper function to create transition matrix from 2D array.
- *
- * @template S - State type
- * @template G - Signal type
- */
-export declare function transitionMatrix<S, G>(matrix: Array<Array<S | G | undefined | null | "">>): TransitionMatrix<NonEmpty<S>, NonEmpty<G>>;
-//# sourceMappingURL=TransitionMatrix.d.ts.map

package/lib/TransitionMatrix.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TransitionMatrix.d.ts","sourceRoot":"","sources":["../src/TransitionMatrix.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,SAAS,GAAG,IAAI,GAAG,KAAK,GAAG,CAAC,CAAC;AAEtE;;;;;;;;;;GAUG;AACH,qBAAa,gBAAgB,CAAC,KAAK,EAAE,MAAM;IACvC,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,WAAW,CAAoD;IAEvE;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,EACjB,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,SAAS,GAAG,IAAI,GAAG,EAAE,CAAC,CAAC,GACpD,gBAAgB,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;IAiD7C;;OAEG;IACH,SAAS,IAAI,KAAK,EAAE;IAIpB;;OAEG;IACH,UAAU,IAAI,MAAM,EAAE;IAItB;;OAEG;IACH,cAAc,IAAI;QAAE,IAAI,EAAE,KAAK,CAAC;QAAC,EAAE,EAAE,KAAK,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE;CAGjE;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,CAAC,EACjC,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,SAAS,GAAG,IAAI,GAAG,EAAE,CAAC,CAAC,GACpD,gBAAgB,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAE5C"}

package/lib/TransitionMatrix.js

@@ -1,104 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransitionMatrix = void 0;
-exports.transitionMatrix = transitionMatrix;
-/**
- * Creates transitions from a 2D matrix representation.
- *
- * Matrix format:
- * - First row: [undefined, ...states] - column headers
- * - Subsequent rows: [signal, ...transitions] - signal + target states
- * - Empty cells: undefined, null, "", or omitted
- *
- * @template STATE - Type for states
- * @template SIGNAL - Type for signals
- */
-class TransitionMatrix {
-    constructor() {
-        this.states = [];
-        this.signals = [];
-        this.transitions = [];
-    }
-    /**
-     * Creates a transition matrix from a 2D array.
-     *
-     * @param matrix - 2D array where:
-     *   - matrix[0] = [undefined, ...states] (header row)
-     *   - matrix[i] = [signal, target1, target2, ...] (transition rows)
-     *
-     * @example
-     * ```typescript
-     * const matrix = [
-     *     [           , "locked"    , "unlocked" ],  // States header
-     *     [ "coin"    , "unlocked" ,             ],  // coin transitions
-     *     [ "push"    ,            , "locked"   ]   // push transitions
-     * ];
-     * ```
-     */
-    static fromArray(matrix) {
-        const instance = new TransitionMatrix();
-        if (matrix.length === 0) {
-            throw new Error('Matrix cannot be empty');
-        }
-        // Extract states from header row (skip first empty cell)
-        const headerRow = matrix[0];
-        const stateValues = headerRow.slice(1).filter(cell => cell !== undefined && cell !== null && cell !== "");
-        // Type assertion: assume header row contains only states
-        instance.states = stateValues;
-        // Process each signal row
-        for (let rowIndex = 1; rowIndex < matrix.length; rowIndex++) {
-            const row = matrix[rowIndex];
-            const signal = row[0];
-            // Skip rows without valid signal
-            if (!signal || signal === "" || signal === null || signal === undefined) {
-                continue;
-            }
-            // Type assertion: assume first column contains only signals
-            instance.signals.push(signal);
-            // Process each state column
-            for (let colIndex = 1; colIndex < row.length; colIndex++) {
-                const targetState = row[colIndex];
-                const fromState = instance.states[colIndex - 1];
-                // If cell has a value, create transition
-                if (targetState && targetState !== "" && targetState !== null && targetState !== undefined && fromState) {
-                    // Type assertion: assume cell values are states
-                    instance.transitions.push({
-                        from: fromState,
-                        to: targetState,
-                        signal: signal
-                    });
-                }
-            }
-        }
-        return instance;
-    }
-    /**
-     * Get all states from the matrix.
-     */
-    getStates() {
-        return [...this.states];
-    }
-    /**
-     * Get all signals from the matrix.
-     */
-    getSignals() {
-        return [...this.signals];
-    }
-    /**
-     * Get all transitions from the matrix.
-     */
-    getTransitions() {
-        return [...this.transitions];
-    }
-}
-exports.TransitionMatrix = TransitionMatrix;
-/**
- * Helper function to create transition matrix from 2D array.
- *
- * @template S - State type
- * @template G - Signal type
- */
-function transitionMatrix(matrix) {
-    return TransitionMatrix.fromArray(matrix);
-}
-//# sourceMappingURL=TransitionMatrix.js.map

package/lib/TransitionMatrix.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"TransitionMatrix.js","sourceRoot":"","sources":["../src/TransitionMatrix.ts"],"names":[],"mappings":";;;AAoHA,4CAIC;AAnHD;;;;;;;;;;GAUG;AACH,MAAa,gBAAgB;IAA7B;QACY,WAAM,GAAY,EAAE,CAAC;QACrB,YAAO,GAAa,EAAE,CAAC;QACvB,gBAAW,GAAiD,EAAE,CAAC;IAyF3E,CAAC;IAvFG;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,SAAS,CACZ,MAAmD;QAEnD,MAAM,QAAQ,GAAG,IAAI,gBAAgB,EAA4B,CAAC;QAElE,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACtB,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC;QAC9C,CAAC;QAED,yDAAyD;QACzD,MAAM,SAAS,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QAC5B,MAAM,WAAW,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CACjD,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,EAAE,CACrD,CAAC;QAEF,yDAAyD;QACzD,QAAQ,CAAC,MAAM,GAAG,WAA4B,CAAC;QAE/C,0BAA0B;QAC1B,KAAK,IAAI,QAAQ,GAAG,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,CAAC;YAC1D,MAAM,GAAG,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;YAC7B,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;YAEtB,iCAAiC;YACjC,IAAI,CAAC,MAAM,IAAI,MAAM,KAAK,EAAE,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;gBACtE,SAAS;YACb,CAAC;YAED,4DAA4D;YAC5D,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,MAAqB,CAAC,CAAC;YAE7C,4BAA4B;YAC5B,KAAK,IAAI,QAAQ,GAAG,CAAC,EAAE,QAAQ,GAAG,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,CAAC;gBACvD,MAAM,WAAW,GAAG,GAAG,CAAC,QAAQ,CAAC,CAAC;gBAClC,MAAM,SAAS,GAAG,QAAQ,CAAC,MAAM,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC;gBAEhD,yCAAyC;gBACzC,IAAI,WAAW,IAAI,WAAW,KAAK,EAAE,IAAI,WAAW,KAAK,IAAI,IAAI,WAAW,KAAK,SAAS,IAAI,SAAS,EAAE,CAAC;oBACtG,gDAAgD;oBAChD,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC;wBACtB,IAAI,EAAE,SAAS;wBACf,EAAE,EAAE,WAA0B;wBAC9B,MAAM,EAAE,MAAqB;qBAChC,CAAC,CAAC;gBACP,CAAC;YACL,CAAC;QACL,CAAC;QAED,OAAO,QAAQ,CAAC;IACpB,CAAC;IAED;;OAEG;IACH,SAAS;QACL,OAAO,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;IAC5B,CAAC;IAED;;OAEG;IACH,UAAU;QACN,OAAO,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;IAC7B,CAAC;IAED;;OAEG;IACH,cAAc;QACV,OAAO,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC;IACjC,CAAC;CACJ;AA5FD,4CA4FC;AAED;;;;;GAKG;AACH,SAAgB,gBAAgB,CAC5B,MAAmD;IAEnD,OAAO,gBAAgB,CAAC,SAAS,CAAO,MAAM,CAAC,CAAC;AACpD,CAAC"}

package/lib/esm/DefaultState.js

@@ -1,10 +0,0 @@
-/**
- * Marker base class for states that should be used processed by invalid signals and
- * in situation, then no transitions set for pair (current signal, current state).
- * Only one state in a state machine can have this role.
- */
-export class DefaultState {
-    isDefaultState() {
-        return true;
-    }
-}