state-machine-cat 10.1.5 → 10.1.7

package/dist/esm/cli/file-name-to-stream.mjs

@@ -0,0 +1,13 @@
+import fs from "node:fs";
+export function getOutStream(pOutputTo) {
+    if ("-" === pOutputTo) {
+        return process.stdout;
+    }
+    return fs.createWriteStream(pOutputTo);
+}
+export function getInStream(pInputFrom) {
+    if ("-" === pInputFrom) {
+        return process.stdin;
+    }
+    return fs.createReadStream(pInputFrom);
+}

package/dist/esm/cli/make-description.mjs

@@ -0,0 +1,21 @@
+import chalk from "chalk";
+import indentString from "indent-string";
+import wrapAnsi from "wrap-ansi";
+import dotToVectorNative from "../render/vector/dot-to-vector-native.mjs";
+function wrapAndIndent(pString) {
+    const lDogmaticMaxConsoleWidth = 78;
+    const lDefaultIndent = 2;
+    const lMaxWidth = lDogmaticMaxConsoleWidth - lDefaultIndent;
+    return indentString(wrapAnsi(pString, lMaxWidth), lDefaultIndent);
+}
+export default (pDotIsAvailable = dotToVectorNative.isAvailable({})) => {
+    const lDescription = "Write beautiful state charts - https://github.com/sverweij/state-machine-cat";
+    const lNode12Warning = "When you want to output svg and the native GraphViz isn't installed, " +
+        "state-machine-cat will fall back to viz.js and you might see " +
+        `${chalk.italic("'Invalid asm.js: Function definition doesn't match use'")}. ` +
+        "It's harmless and your svg will come out ok. See " +
+        `https://github.com/sverweij/state-machine-cat/blob/develop/docs/faq.md#viz`;
+    return indentString(pDotIsAvailable
+        ? lDescription
+        : `${lDescription}\n\n${wrapAndIndent(chalk.dim(lNode12Warning))}`);
+};

package/dist/esm/cli/normalize.mjs

@@ -0,0 +1,95 @@
+import path from "node:path";
+import options from "../options.mjs";
+import { parse as parseAttributes } from "./attributes-parser.mjs";
+const INPUT_EXTENSIONS = {
+    ".smcat": "smcat",
+    ".scxml": "scxml",
+    ".xml": "scxml",
+    ".json": "json",
+    ".ast": "json",
+};
+const OUTPUT_EXTENSIONS = {
+    ".ast": "json",
+    ".dot": "dot",
+    ".eps": "eps",
+    ".json": "json",
+    ".pdf": "pdf",
+    ".png": "png",
+    ".ps": "ps",
+    ".ps2": "ps2",
+    ".scjson": "scjson",
+    ".scxml": "scxml",
+    ".smcat": "smcat",
+    ".svg": "svg",
+};
+function classifyExtension(pString, pExtensionMap, pDefault) {
+    return pExtensionMap[path.extname(pString)] || pDefault;
+}
+function outputType2Extension(pOutputType) {
+    const lExceptions = {
+        oldeps: "eps",
+        oldps: "ps",
+        oldps2: "ps",
+        oldsvg: "svg",
+        ps2: "ps",
+    };
+    return lExceptions[pOutputType] || pOutputType;
+}
+function deriveOutputFromInput(pInputFrom, pOutputType) {
+    const lExtension = outputType2Extension(pOutputType);
+    if (!pInputFrom || "-" === pInputFrom) {
+        return "-";
+    }
+    return path
+        .join(path.dirname(pInputFrom), path.basename(pInputFrom, path.extname(pInputFrom)))
+        .concat(".")
+        .concat(lExtension);
+}
+function determineOutputTo(pOutputTo, pInputFrom, pOutputType) {
+    return pOutputTo ? pOutputTo : deriveOutputFromInput(pInputFrom, pOutputType);
+}
+function determineInputType(pInputFrom, pInputType) {
+    if (pInputType) {
+        return pInputType;
+    }
+    return classifyExtension(pInputFrom, INPUT_EXTENSIONS, options.getAllowedValues().inputType.default);
+}
+function determineOutputType(pOutputTo, pOutputType) {
+    if (pOutputType) {
+        return pOutputType;
+    }
+    if (pOutputTo) {
+        return classifyExtension(pOutputTo, OUTPUT_EXTENSIONS, options.getAllowedValues().outputType.default);
+    }
+    return options.getAllowedValues().outputType.default;
+}
+function determineParameter(pOptions, pParameter) {
+    return Object.prototype.hasOwnProperty.call(pOptions, pParameter)
+        ?
+            pOptions[pParameter]
+        :
+            options.getAllowedValues()[pParameter].default;
+}
+function determineDotAttributes(pOptions, pDotAttributes) {
+    return Boolean(pOptions?.[pDotAttributes]) &&
+        typeof pOptions[pDotAttributes] === "string"
+        ? parseAttributes(pOptions[pDotAttributes])
+        : [];
+}
+export default function normalize(pArgument = "-", pLooseOptions = {}) {
+    const lNormalizedInputFrom = pArgument || "-";
+    const lNormalizedInputType = determineInputType(lNormalizedInputFrom, pLooseOptions.inputType);
+    const lNormalizedOutputType = determineOutputType(pLooseOptions.outputTo, pLooseOptions.outputType);
+    return {
+        inputFrom: lNormalizedInputFrom,
+        inputType: lNormalizedInputType,
+        outputType: lNormalizedOutputType,
+        outputTo: determineOutputTo(pLooseOptions.outputTo, lNormalizedInputFrom, lNormalizedOutputType),
+        engine: determineParameter(pLooseOptions, "engine"),
+        direction: determineParameter(pLooseOptions, "direction"),
+        dotGraphAttrs: determineDotAttributes(pLooseOptions, "dotGraphAttrs"),
+        dotNodeAttrs: determineDotAttributes(pLooseOptions, "dotNodeAttrs"),
+        dotEdgeAttrs: determineDotAttributes(pLooseOptions, "dotEdgeAttrs"),
+        desugar: pLooseOptions?.desugar ?? false,
+    };
+}

package/dist/esm/cli/validations.mjs

@@ -0,0 +1,70 @@
+import fs from "node:fs";
+import smcat from "../index-node.mjs";
+import { parse as parseAttributes } from "./attributes-parser.mjs";
+const allowedValues = smcat.getAllowedValues();
+function getName(pValue) {
+    return pValue.name;
+}
+const VALID_OUTPUT_TYPES = allowedValues.outputType.values.map(getName);
+const VALID_INPUT_TYPES = allowedValues.inputType.values.map(getName);
+const VALID_ENGINES = allowedValues.engine.values.map(getName);
+const VALID_DIRECTIONS = allowedValues.direction.values.map(getName);
+function isStdout(pFilename) {
+    return "-" === pFilename;
+}
+function fileExists(pFilename) {
+    try {
+        if (!isStdout(pFilename)) {
+            fs.accessSync(pFilename, fs.constants.R_OK);
+        }
+        return true;
+    }
+    catch (pError) {
+        return false;
+    }
+}
+function validOption(pOption, pValidValues, pError) {
+    if (pValidValues.includes(pOption)) {
+        return pOption;
+    }
+    throw new Error(pError);
+}
+export default {
+    validOutputType: (pType) => validOption(pType, VALID_OUTPUT_TYPES, `\n  error: '${pType}' is not a valid output type. smcat can emit:` +
+        `\n          ${VALID_OUTPUT_TYPES.join(", ")}\n\n`),
+    validInputType: (pType) => validOption(pType, VALID_INPUT_TYPES, `\n  error: '${pType}' is not a valid input type.` +
+        `\n         smcat can read ${VALID_INPUT_TYPES.join(", ")}\n\n`),
+    validEngine: (pEngine) => validOption(pEngine, VALID_ENGINES, `\n  error: '${pEngine}' is not a valid input type.` +
+        `\n         you can choose from ${VALID_ENGINES.join(", ")}\n\n`),
+    validDirection: (pDirection) => validOption(pDirection, VALID_DIRECTIONS, `\n  error: '${pDirection}' is not a valid direction.` +
+        `\n         you can choose from ${VALID_DIRECTIONS.join(", ")}\n\n`),
+    validDotAttrs: (pDotAttributes) => {
+        try {
+            parseAttributes(pDotAttributes);
+            return pDotAttributes;
+        }
+        catch (pError) {
+            throw new Error(`Invalid dot attributes: ${pError.message}`);
+        }
+    },
+    validateArguments(pOptions) {
+        if (!pOptions.inputFrom) {
+            throw new Error(`\n  error: Please specify an input file.\n\n`);
+        }
+        if (!pOptions.outputTo) {
+            throw new Error(`\n  error: Please specify an output file.\n\n`);
+        }
+        if (!fileExists(pOptions.inputFrom)) {
+            throw new Error(`\n  error: Failed to open input file '${pOptions.inputFrom}'\n\n`);
+        }
+        return pOptions;
+    },
+    validOutputTypeRE: VALID_OUTPUT_TYPES.join("|"),
+    defaultOutputType: allowedValues.outputType.default,
+    validInputTypeRE: VALID_INPUT_TYPES.join("|"),
+    defaultInputType: allowedValues.inputType.default,
+    validEngineRE: VALID_ENGINES.join("|"),
+    defaultEngine: allowedValues.engine.default,
+    validDirectionRE: VALID_DIRECTIONS.join("|"),
+    defaultDirection: allowedValues.direction.default,
+};

package/dist/esm/index-node.mjs

@@ -0,0 +1,16 @@
+import options from "./options.mjs";
+import parse from "./parse/index.mjs";
+import desugar from "./transform/desugar.mjs";
+import getRenderFunction from "./render/index-node.mjs";
+import { version } from "./version.mjs";
+export default {
+    render(pScript, pOptions) {
+        const lStateMachine = parse.getAST(pScript, pOptions);
+        const lDesugar = options.getOptionValue(pOptions, "desugar");
+        return getRenderFunction(options.getOptionValue(pOptions, "outputType"))(lDesugar ? desugar(lStateMachine) : lStateMachine, pOptions);
+    },
+    version,
+    getAllowedValues() {
+        return options.getAllowedValues();
+    },
+};

package/dist/esm/index.mjs

@@ -0,0 +1,19 @@
+import options from "./options.mjs";
+import parse from "./parse/index.mjs";
+import desugar from "./transform/desugar.mjs";
+import getRenderFunction from "./render/index.mjs";
+import { version as _version } from "./version.mjs";
+export function render(pScript, pOptions) {
+    const lStateMachine = parse.getAST(pScript, pOptions);
+    const lDesugar = options.getOptionValue(pOptions, "desugar");
+    return getRenderFunction(options.getOptionValue(pOptions, "outputType"))(lDesugar ? desugar(lStateMachine) : lStateMachine, pOptions);
+}
+export const version = _version;
+export function getAllowedValues() {
+    return options.getAllowedValues();
+}
+export default {
+    render,
+    version,
+    getAllowedValues,
+};

package/dist/esm/options.mjs

@@ -0,0 +1,61 @@
+const ALLOWED_VALUES = Object.freeze({
+    inputType: {
+        default: "smcat",
+        values: [{ name: "smcat" }, { name: "json" }, { name: "scxml" }],
+    },
+    outputType: {
+        default: "svg",
+        values: [
+            { name: "ast" },
+            { name: "dot" },
+            { name: "eps" },
+            { name: "json" },
+            { name: "oldeps" },
+            { name: "oldps" },
+            { name: "oldps2" },
+            { name: "oldsvg" },
+            { name: "pdf" },
+            { name: "png" },
+            { name: "ps" },
+            { name: "ps2" },
+            { name: "scjson" },
+            { name: "scxml" },
+            { name: "smcat" },
+            { name: "svg" },
+        ],
+    },
+    engine: {
+        default: "dot",
+        values: [
+            { name: "dot" },
+            { name: "circo" },
+            { name: "fdp" },
+            { name: "neato" },
+            { name: "osage" },
+            { name: "twopi" },
+        ],
+    },
+    direction: {
+        default: "top-down",
+        values: [
+            { name: "top-down" },
+            { name: "bottom-top" },
+            { name: "left-right" },
+            { name: "right-left" },
+        ],
+    },
+    desugar: {
+        default: false,
+        values: [{ name: true }, { name: false }],
+    },
+});
+function getOptionValue(pOptions, pOptionName) {
+    return pOptions?.[pOptionName] ?? ALLOWED_VALUES[pOptionName].default;
+}
+function getAllowedValues() {
+    return ALLOWED_VALUES;
+}
+export default {
+    getAllowedValues,
+    getOptionValue,
+};

package/dist/esm/parse/index.mjs

@@ -0,0 +1,27 @@
+import Ajv from "ajv";
+import options from "../options.mjs";
+import { parse as parseSmCat } from "./smcat/smcat-parser.mjs";
+import { parse as parseSCXML } from "./scxml/index.mjs";
+import $schema from "./smcat-ast.schema.mjs";
+const ajv = new Ajv();
+function validateAgainstSchema(pSchema, pObject) {
+    if (!ajv.validate(pSchema, pObject)) {
+        throw new Error(`The provided JSON is not a valid state-machine-cat AST: ${ajv.errorsText()}.\n`);
+    }
+}
+export default {
+    getAST(pScript, pOptions) {
+        let lReturnValue = pScript;
+        if (options.getOptionValue(pOptions, "inputType") === "smcat") {
+            lReturnValue = parseSmCat(pScript);
+        }
+        else if (options.getOptionValue(pOptions, "inputType") === "scxml") {
+            lReturnValue = parseSCXML(pScript);
+        }
+        else if (typeof pScript === "string") {
+            lReturnValue = JSON.parse(pScript);
+        }
+        validateAgainstSchema($schema, lReturnValue);
+        return lReturnValue;
+    },
+};

package/dist/esm/parse/parser-helpers.mjs

@@ -0,0 +1,175 @@
+import StateMachineModel from "../state-machine-model.mjs";
+const TRIGGER_RE_AS_A_STRING = "^(entry|activity|exit)\\s*/\\s*([^\\n$]*)(\\n|$)";
+const TRIGGER_RE = new RegExp(TRIGGER_RE_AS_A_STRING);
+function stateExists(pKnownStateNames, pName) {
+    return pKnownStateNames.includes(pName);
+}
+const RE2STATE_TYPE = [
+    {
+        re: /initial/,
+        stateType: "initial",
+    },
+    {
+        re: /final/,
+        stateType: "final",
+    },
+    {
+        re: /parallel/,
+        stateType: "parallel",
+    },
+    {
+        re: /(deep.*history)|(history.*deep)/,
+        stateType: "deephistory",
+    },
+    {
+        re: /history/,
+        stateType: "history",
+    },
+    {
+        re: /^\^.*/,
+        stateType: "choice",
+    },
+    {
+        re: /^].*/,
+        stateType: "forkjoin",
+    },
+];
+function matches(pName) {
+    return (pEntry) => pEntry.re.test(pName);
+}
+function getStateType(pName) {
+    return (RE2STATE_TYPE.find(matches(pName)) || { stateType: "regular" })
+        .stateType;
+}
+function initState(pName) {
+    return {
+        name: pName,
+        type: getStateType(pName),
+    };
+}
+function isComposite(pState) {
+    return Boolean(pState.statemachine);
+}
+function getAlreadyDeclaredStates(pStateMachine) {
+    const lStates = pStateMachine?.states ?? [];
+    return lStates.filter(isComposite).reduce((pAllStateNames, pThisState) => pAllStateNames.concat(getAlreadyDeclaredStates(pThisState.statemachine)), lStates.map(({ name }) => name));
+}
+function extractUndeclaredStates(pStateMachine, pKnownStateNames) {
+    pKnownStateNames = pKnownStateNames
+        ? pKnownStateNames
+        : getAlreadyDeclaredStates(pStateMachine);
+    pStateMachine.states = pStateMachine?.states ?? [];
+    const lTransitions = pStateMachine?.transitions ?? [];
+    pStateMachine.states.filter(isComposite).forEach((pState) => {
+        pState.statemachine.states = extractUndeclaredStates(pState.statemachine, pKnownStateNames);
+    });
+    lTransitions.forEach((pTransition) => {
+        if (!stateExists(pKnownStateNames, pTransition.from)) {
+            pKnownStateNames.push(pTransition.from);
+            pStateMachine.states.push(initState(pTransition.from));
+        }
+        if (!stateExists(pKnownStateNames, pTransition.to)) {
+            pKnownStateNames.push(pTransition.to);
+            pStateMachine.states.push(initState(pTransition.to));
+        }
+    });
+    return pStateMachine.states;
+}
+function classifyForkJoin(pInComingCount, pOutGoingCount) {
+    let lReturnValue = "junction";
+    if (pInComingCount <= 1 && pOutGoingCount > 1) {
+        lReturnValue = "fork";
+    }
+    if (pInComingCount > 1 && pOutGoingCount <= 1) {
+        lReturnValue = "join";
+    }
+    return lReturnValue;
+}
+function classifyForkJoins(pStateMachine, pFlattenedStateMachineModel = new StateMachineModel(pStateMachine)) {
+    pStateMachine.states = pStateMachine.states.map((pState) => {
+        if (pState.type === "forkjoin" && !pState.typeExplicitlySet) {
+            const lInComingCount = pFlattenedStateMachineModel.findTransitionsByTo(pState.name).length;
+            const lOutGoingCount = pFlattenedStateMachineModel.findTransitionsByFrom(pState.name).length;
+            pState.type = classifyForkJoin(lInComingCount, lOutGoingCount);
+        }
+        if (pState.statemachine) {
+            pState.statemachine = classifyForkJoins(pState.statemachine, pFlattenedStateMachineModel);
+        }
+        return pState;
+    });
+    return pStateMachine;
+}
+function stateEqual(pStateOne, pStateTwo) {
+    return pStateOne.name === pStateTwo.name;
+}
+function uniq(pArray, pEqualFunction) {
+    return pArray.reduce((pBag, pMarble) => {
+        const lMarbleIndex = pBag.findIndex((pBagItem) => pEqualFunction(pBagItem, pMarble));
+        if (lMarbleIndex > -1) {
+            pBag[lMarbleIndex] = pMarble;
+            return pBag;
+        }
+        return pBag.concat(pMarble);
+    }, []);
+}
+function parseTransitionExpression(pString) {
+    const lTransitionExpressionRe = /([^[/]+)?(\[[^\]]+\])?[^/]*(\/.+)?/;
+    const lReturnValue = {};
+    const lMatchResult = pString.match(lTransitionExpressionRe);
+    const lEventPos = 1;
+    const lConditionPos = 2;
+    const lActionPos = 3;
+    if (lMatchResult[lEventPos]) {
+        lReturnValue.event = lMatchResult[lEventPos].trim();
+    }
+    if (lMatchResult[lConditionPos]) {
+        lReturnValue.cond = lMatchResult[lConditionPos].slice(1, -1).trim();
+    }
+    if (lMatchResult[lActionPos]) {
+        lReturnValue.action = lMatchResult[lActionPos]
+            .slice(1, lMatchResult[lActionPos].length)
+            .trim();
+    }
+    return lReturnValue;
+}
+function setIf(pObject, pProperty, pValue, pCondition = Boolean) {
+    if (pCondition(pValue)) {
+        pObject[pProperty] = pValue;
+    }
+}
+function setIfNotEmpty(pObject, pProperty, pValue) {
+    setIf(pObject, pProperty, pValue, (pX) => pX && pX.length > 0);
+}
+function extractAction(pActivityCandidate) {
+    const lMatch = pActivityCandidate.match(TRIGGER_RE);
+    const lTypePos = 1;
+    const lBodyPos = 2;
+    if (lMatch) {
+        return {
+            type: lMatch[lTypePos],
+            body: lMatch[lBodyPos],
+        };
+    }
+    return {
+        type: "activity",
+        body: pActivityCandidate,
+    };
+}
+function extractActions(pString) {
+    return pString
+        .split(/\n\s*/g)
+        .map((pActivityCandidate) => pActivityCandidate.trim())
+        .map(extractAction);
+}
+export default {
+    initState,
+    extractUndeclaredStates,
+    classifyForkJoins,
+    getStateType,
+    stateEqual,
+    uniq,
+    parseTransitionExpression,
+    extractActions,
+    setIf,
+    setIfNotEmpty,
+};

package/dist/esm/parse/scxml/index.mjs

@@ -0,0 +1,136 @@
+import fastxml from "fast-xml-parser";
+import he from "he";
+import castArray from "lodash/castArray.js";
+import utl from "../../transform/utl.mjs";
+import parserHelpers from "../parser-helpers.mjs";
+import { normalizeMachine } from "./normalize-machine.mjs";
+const formatLabel = utl.formatLabel;
+function extractActions(pState, pActionType) {
+    return castArray(pState[pActionType]).map((pAction) => ({
+        type: pActionType === "onexit" ? "exit" : "entry",
+        body: he.decode(pAction).trim(),
+    }));
+}
+function extractActionsFromInvokes(pInvokeTriggers) {
+    return castArray(pInvokeTriggers).map((pInvokeTrigger) => {
+        const lId = he.decode(pInvokeTrigger.id || "").trim();
+        return {
+            type: "activity",
+            body: lId || he.decode(pInvokeTrigger || "").trim(),
+        };
+    });
+}
+function deriveActions(pState) {
+    let lReturnValue = [];
+    if (pState.onentry) {
+        lReturnValue = lReturnValue.concat(extractActions(pState, "onentry"));
+    }
+    if (pState.invoke) {
+        lReturnValue = lReturnValue.concat(extractActionsFromInvokes(pState.invoke));
+    }
+    if (pState.onexit) {
+        lReturnValue = lReturnValue.concat(extractActions(pState, "onexit"));
+    }
+    return lReturnValue;
+}
+function deriveStateType(pType, pState) {
+    return pType === "history" && pState.type === "deep" ? "deephistory" : pType;
+}
+function mapState(pType) {
+    return (pState) => {
+        const lReturnValue = {
+            name: pState.id,
+            type: deriveStateType(pType, pState),
+        };
+        if (parserHelpers.getStateType(pState.id) !== lReturnValue.type) {
+            lReturnValue.typeExplicitlySet = true;
+        }
+        if (pState.onentry || pState.onexit || pState.invoke) {
+            lReturnValue.actions = deriveActions(pState);
+        }
+        if (Object.keys(pState).some((pKey) => ["initial", "state", "history", "parallel", "final"].includes(pKey))) {
+            lReturnValue.statemachine = mapMachine(pState);
+        }
+        return lReturnValue;
+    };
+}
+function extractTransitionAttributesFromObject(pTransition) {
+    const lReturnValue = {};
+    if (pTransition.event) {
+        lReturnValue.event = pTransition.event.split(/\s+/).join("\n");
+    }
+    if (pTransition.cond) {
+        lReturnValue.cond = pTransition.cond;
+    }
+    if (pTransition["#text"]) {
+        lReturnValue.action = he.decode(pTransition["#text"]).trim();
+    }
+    if (pTransition.type) {
+        lReturnValue.type = pTransition.type;
+    }
+    return lReturnValue;
+}
+function extractTransitionAttributes(pTransition) {
+    const lReturnValue = {};
+    if (typeof pTransition === "string") {
+        lReturnValue.action = he.decode(pTransition).trim();
+    }
+    else {
+        Object.assign(lReturnValue, extractTransitionAttributesFromObject(pTransition));
+    }
+    const lLabel = formatLabel(lReturnValue.event, lReturnValue.cond, lReturnValue.action);
+    if (lLabel) {
+        lReturnValue.label = lLabel;
+    }
+    return lReturnValue;
+}
+function reduceTransition(pState) {
+    return (pAllTransitions, pTransition) => {
+        const lTargets = (pTransition?.target ?? pState.id).split(/\s+/);
+        const lTransitionAttributes = extractTransitionAttributes(pTransition);
+        return pAllTransitions.concat(lTargets.map((pTarget) => ({
+            from: pState.id,
+            to: pTarget,
+            ...lTransitionAttributes,
+        })));
+    };
+}
+function extractTransitions(pStates) {
+    return pStates
+        .filter((pState) => Object.prototype.hasOwnProperty.call(pState, "transition"))
+        .reduce((pAllTransitions, pThisState) => pAllTransitions.concat(castArray(pThisState.transition).reduce(reduceTransition(pThisState), [])), []);
+}
+function mapMachine(pSCXMLStateMachine) {
+    const lNormalizedMachine = normalizeMachine(pSCXMLStateMachine);
+    const lReturnValue = {
+        states: lNormalizedMachine.initial
+            .map(mapState("initial"))
+            .concat(lNormalizedMachine.state.map(mapState("regular")))
+            .concat(lNormalizedMachine.parallel.map(mapState("parallel")))
+            .concat(lNormalizedMachine.history.map(mapState("history")))
+            .concat(lNormalizedMachine.final.map(mapState("final"))),
+    };
+    const lTransitions = extractTransitions(lNormalizedMachine.initial)
+        .concat(extractTransitions(lNormalizedMachine.state))
+        .concat(extractTransitions(lNormalizedMachine.parallel));
+    if (lTransitions.length > 0) {
+        lReturnValue.transitions = lTransitions;
+    }
+    return lReturnValue;
+}
+export function parse(pSCXMLString) {
+    const lTrimmedSCXMLString = pSCXMLString.trim();
+    if (fastxml.validate(lTrimmedSCXMLString) === true) {
+        const lXMLAsJSON = fastxml.parse(lTrimmedSCXMLString, {
+            attributeNamePrefix: "",
+            ignoreAttributes: false,
+            tagValueProcessor: (pTagValue) => he.decode(pTagValue),
+            stopNodes: ["onentry", "onexit", "transition"],
+        });
+        return mapMachine(lXMLAsJSON?.scxml ?? {
+            xmlns: "http://www.w3.org/2005/07/scxml",
+            version: "1.0",
+        });
+    }
+    throw new Error("That doesn't look like valid xml ...\n");
+}

package/dist/esm/parse/scxml/normalize-machine.mjs

@@ -0,0 +1,44 @@
+import castArray from "lodash/castArray.js";
+function normalizeInitialFromObject(pInitialObject, pId) {
+    const lReturnValue = {
+        id: pId ? `${pId}.initial` : "initial",
+    };
+    if (pInitialObject.transition) {
+        Object.assign(lReturnValue, {
+            transition: [pInitialObject.transition],
+        });
+    }
+    return lReturnValue;
+}
+function normalizeInitialFromString(pString) {
+    return {
+        id: "initial",
+        transition: [
+            {
+                target: pString,
+            },
+        ],
+    };
+}
+function normalizeInitial(pMachine) {
+    const lReturnValue = [];
+    if (pMachine.initial) {
+        if (typeof pMachine.initial === "string") {
+            lReturnValue.push(normalizeInitialFromString(pMachine.initial));
+        }
+        else {
+            lReturnValue.push(normalizeInitialFromObject(pMachine.initial, pMachine.id));
+        }
+    }
+    return lReturnValue;
+}
+export function normalizeMachine(pMachine) {
+    return {
+        ...pMachine,
+        initial: normalizeInitial(pMachine),
+        state: castArray(pMachine?.state ?? []),
+        parallel: castArray(pMachine?.parallel ?? []),
+        history: castArray(pMachine?.history ?? []),
+        final: castArray(pMachine?.final ?? []),
+    };
+}