state-machine-cat 10.1.2 → 10.1.5

package/src/index-node.mjs

@@ -1,52 +1,18 @@
+// @ts-check
 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";
 
-const KNOWN_OPTIONS = [
-  "outputType",
-  "inputType",
-  "engine",
-  "direction",
-  "dotNodeAttrs",
-  "dotEdgeAttrs",
-  "desugar",
-];
-
-function isKnownOption(pKnownOptions) {
-  return (pCandidateString) => pKnownOptions.includes(pCandidateString);
-}
-
-/**
- * Remove all attributes from the input object (which'd typically be
- * originating from commander) that are not known options options so
- * a clean object can be passed through.
- *
- * @param {any} pOptions - an options object e.g. as output from commander
- * @param {string[]} pKnownOptions - a list of known options
- * @return {any} - an options object that only contains stuff we care about
- */
-function ejectUnknownOptions(pOptions, pKnownOptions) {
-  return Object.keys(pOptions)
-    .filter(isKnownOption(pKnownOptions))
-    .reduce((pAll, pKey) => {
-      // eslint-disable-next-line security/detect-object-injection
-      pAll[pKey] = pOptions[pKey];
-      return pAll;
-    }, {});
-}
-
 export default {
   /**
-   * Translates the input script to an outputscript.
+   * Translates the input script to an output-script.
    *
-   * @param  {string} pScript     The script to translate
-   * @param  {object} pOptions    options influencing parsing & rendering.
-   *                              See below for the complete list.
-   * @return {string|void}        nothing if a callback was passed, the
-   *                              string with the rendered content if
-   *                              no callback was passed and no error was found
+   * @param  {string|import("../types/state-machine-cat").IStateMachine} pScript
+   *                              The script to translate
+   * @param  {import("../types/state-machine-cat").IRenderOptions} pOptions
+   *                              options influencing parsing & rendering.
    * @throws {Error}              if an error occurred and no callback
    *                              function was passed: the error
    *
@@ -54,13 +20,15 @@ export default {
    *
    */
   render(pScript, pOptions) {
-    const lOptions = ejectUnknownOptions(pOptions, KNOWN_OPTIONS);
-    const lAST = parse.getAST(pScript, lOptions);
-    const lDesugar = options.getOptionValue(lOptions, "desugar");
+    const lStateMachine = parse.getAST(pScript, pOptions);
+    const lDesugar = options.getOptionValue(pOptions, "desugar");
 
-    return getRenderFunction(options.getOptionValue(lOptions, "outputType"))(
-      lDesugar ? desugar(lAST) : lAST,
-      lOptions
+    // @ts-expect-error should be cast to OutputTypeType - or the getOptionValue
+    // function should be refactored to be more explicit in type it returns
+    // when we ask for outputType
+    return getRenderFunction(options.getOptionValue(pOptions, "outputType"))(
+      lDesugar ? desugar(lStateMachine) : lStateMachine,
+      pOptions
     );
   },
 
@@ -79,7 +47,7 @@ export default {
    * - the possible values in an array of objects, each of which
    *   has the properties:
    *   - name: the value
-   *
+   * @returns {import("../types/state-machine-cat").IAllowedValues}
    */
   getAllowedValues() {
     return options.getAllowedValues();

package/src/index.mjs

@@ -1,3 +1,4 @@
+// @ts-check
 /* eslint-disable budapestian/global-constant-pattern */
 import options from "./options.mjs";
 import parse from "./parse/index.mjs";
@@ -8,12 +9,11 @@ import { version as _version } from "./version.mjs";
 /**
  * Translates the input script to an output-script.
  *
- * @param  {string} pScript     The script to translate
- * @param  {object} pOptions    options influencing parsing & rendering.
- *                              See below for the complete list.
- * @return {string|void}        nothing if a callback was passed, the
- *                              string with the rendered content if
- *                              no callback was passed and no error was found
+ * @param  {string|import("../types/state-machine-cat").IStateMachine} pScript
+ *                              The script to translate
+ * @param  {import("../types/state-machine-cat").IRenderOptions} pOptions
+ *                              options influencing parsing & rendering.
+ * @return {string}
  * @throws {Error}              if an error occurred and no callback
  *                              function was passed: the error
  *
@@ -21,11 +21,11 @@ import { version as _version } from "./version.mjs";
  *
  */
 export function render(pScript, pOptions) {
-  const lAST = parse.getAST(pScript, pOptions);
+  const lStateMachine = parse.getAST(pScript, pOptions);
   const lDesugar = options.getOptionValue(pOptions, "desugar");
 
   return getRenderFunction(options.getOptionValue(pOptions, "outputType"))(
-    lDesugar ? desugar(lAST) : lAST,
+    lDesugar ? desugar(lStateMachine) : lStateMachine,
     pOptions
   );
 }
@@ -45,7 +45,7 @@ export const version = _version;
  * - the possible values in an array of objects, each of which
  *   has the properties:
  *   - name: the value
- *
+ * @returns {import("../types/state-machine-cat").IAllowedValues}
  */
 export function getAllowedValues() {
   return options.getAllowedValues();

package/src/options.mjs

@@ -1,3 +1,5 @@
+// @ts-check
+/** @type {import("../types/state-machine-cat").IAllowedValues} */
 const ALLOWED_VALUES = Object.freeze({
   inputType: {
     default: "smcat",
@@ -6,21 +8,22 @@ const ALLOWED_VALUES = Object.freeze({
   outputType: {
     default: "svg",
     values: [
-      { name: "svg" },
-      { name: "eps" },
-      { name: "ps" },
-      { name: "ps2" },
+      { name: "ast" },
       { name: "dot" },
-      { name: "smcat" },
+      { name: "eps" },
       { name: "json" },
-      { name: "ast" },
-      { name: "scxml" },
-      { name: "oldsvg" },
-      { name: "oldps2" },
       { name: "oldeps" },
-      { name: "scjson" },
+      { name: "oldps" },
+      { name: "oldps2" },
+      { name: "oldsvg" },
       { name: "pdf" },
       { name: "png" },
+      { name: "ps" },
+      { name: "ps2" },
+      { name: "scjson" },
+      { name: "scxml" },
+      { name: "smcat" },
+      { name: "svg" },
     ],
   },
   engine: {
@@ -53,15 +56,18 @@ const ALLOWED_VALUES = Object.freeze({
  * Returns the value for the option in the pOption object, and the default
  * for that option in all other cases
  *
- * @param {any} pOptions - the options as passed in the api `render` function
- * @param {string} pOptionName - the name of the option
- * @return {any} value
+ * @param {import("../types/state-machine-cat").IRenderOptions} pOptions - the options as passed in the api `render` function
+ * @param {keyof import("../types/state-machine-cat").IRenderOptions} pOptionName - the name of the option
+ * @return {string|boolean} value
  */
 function getOptionValue(pOptions, pOptionName) {
   // eslint-disable-next-line security/detect-object-injection
   return pOptions?.[pOptionName] ?? ALLOWED_VALUES[pOptionName].default;
 }
 
+/**
+ * @returns {import("../types/state-machine-cat").IAllowedValues}
+ */
 function getAllowedValues() {
   return ALLOWED_VALUES;
 }

package/src/parse/index.mjs

@@ -1,3 +1,4 @@
+// @ts-check
 import Ajv from "ajv";
 import options from "../options.mjs";
 import { parse as parseSmCat } from "./smcat/smcat-parser.mjs";
@@ -6,6 +7,11 @@ import $schema from "./smcat-ast.schema.mjs";
 
 const ajv = new Ajv();
 
+/**
+ * @param {typeof $schema} pSchema
+ * @param {any} pObject
+ * @throws {Error}
+ */
 function validateAgainstSchema(pSchema, pObject) {
   if (!ajv.validate(pSchema, pObject)) {
     throw new Error(
@@ -15,12 +21,18 @@ function validateAgainstSchema(pSchema, pObject) {
 }
 
 export default {
+  /**
+   * @param {string|import("../../types/state-machine-cat").IStateMachine} pScript
+   * @param {import("../../types/state-machine-cat").IRenderOptions} pOptions
+   * @returns {import("../../types/state-machine-cat").IStateMachine}
+   */
   getAST(pScript, pOptions) {
     let lReturnValue = pScript;
 
     if (options.getOptionValue(pOptions, "inputType") === "smcat") {
       lReturnValue = parseSmCat(pScript);
     } else if (options.getOptionValue(pOptions, "inputType") === "scxml") {
+      // @ts-expect-error inputType scxml => it's a string
       lReturnValue = parseSCXML(pScript);
     } else if (typeof pScript === "string") {
       // json
@@ -29,6 +41,7 @@ export default {
 
     validateAgainstSchema($schema, lReturnValue);
 
+    // @ts-expect-error by here lReturnValue is bound to be an IStateMachine
     return lReturnValue;
   },
 };

package/src/parse/parser-helpers.mjs

@@ -1,3 +1,4 @@
+// @ts-check
 /* eslint-disable security/detect-object-injection */
 import StateMachineModel from "../state-machine-model.mjs";
 
@@ -6,10 +7,20 @@ const TRIGGER_RE_AS_A_STRING =
 /* eslint security/detect-non-literal-regexp:0 */
 const TRIGGER_RE = new RegExp(TRIGGER_RE_AS_A_STRING);
 
+/**
+ * @param {string[]} pKnownStateNames
+ * @param {string} pName
+ * @returns {boolean}
+ */
 function stateExists(pKnownStateNames, pName) {
   return pKnownStateNames.includes(pName);
 }
-
+/**
+ * @type {{
+ *   re:RegExp;
+ *   stateType: import("../../types/state-machine-cat.js").StateType;
+ * }[]}
+ */
 const RE2STATE_TYPE = [
   {
     re: /initial/,
@@ -45,11 +56,19 @@ function matches(pName) {
   return (pEntry) => pEntry.re.test(pName);
 }
 
+/**
+ * @param {string} [pName]
+ * @returns {import("../../types/state-machine-cat.js").StateType}
+ */
 function getStateType(pName) {
   return (RE2STATE_TYPE.find(matches(pName)) || { stateType: "regular" })
     .stateType;
 }
 
+/**
+ * @param {string} pName
+ * @returns {import("../../types/state-machine-cat.js").IState}
+ */
 function initState(pName) {
   return {
     name: pName,
@@ -57,30 +76,45 @@ function initState(pName) {
   };
 }
 
+/**
+ * @param {import("../../types/state-machine-cat.js").IState} pState
+ * @returns {boolean}
+ */
 function isComposite(pState) {
   return Boolean(pState.statemachine);
 }
 
+/**
+ * @param {import("../../types/state-machine-cat.js").IStateMachine} [pStateMachine]
+ * @returns {string[]}
+ */
 function getAlreadyDeclaredStates(pStateMachine) {
-  const lStates = pStateMachine.states || [];
+  const lStates = pStateMachine?.states ?? [];
 
   return lStates.filter(isComposite).reduce(
     (pAllStateNames, pThisState) =>
       pAllStateNames.concat(getAlreadyDeclaredStates(pThisState.statemachine)),
-    lStates.map((pState) => pState.name)
+    lStates.map(({ name }) => name)
   );
 }
 
+/**
+ * @param {import("../../types/state-machine-cat.js").IStateMachine} pStateMachine
+ * @param {string[]} pKnownStateNames
+ * @returns {import("../../types/state-machine-cat.js").IState[]}
+ */
 function extractUndeclaredStates(pStateMachine, pKnownStateNames) {
   pKnownStateNames = pKnownStateNames
     ? pKnownStateNames
     : getAlreadyDeclaredStates(pStateMachine);
 
-  pStateMachine.states = pStateMachine.states || [];
-  const lTransitions = pStateMachine.transitions || [];
+  pStateMachine.states = pStateMachine?.states ?? [];
+  const lTransitions = pStateMachine?.transitions ?? [];
 
   pStateMachine.states.filter(isComposite).forEach((pState) => {
+    // @ts-expect-error isComposite guarantees the statemachine attribute exists, TS doesn't understand that yet, though
     pState.statemachine.states = extractUndeclaredStates(
+      // @ts-expect-error isComposite guarantees the statemachine attribute exists, TS doesn't understand that yet, though
       pState.statemachine,
       pKnownStateNames
     );
@@ -99,7 +133,13 @@ function extractUndeclaredStates(pStateMachine, pKnownStateNames) {
   return pStateMachine.states;
 }
 
+/**
+ * @param {number} pInComingCount
+ * @param {number} pOutGoingCount
+ * @returns {import("../../types/state-machine-cat.js").StateType}
+ */
 function classifyForkJoin(pInComingCount, pOutGoingCount) {
+  /** @type {import("../../types/state-machine-cat.js").StateType} */
   let lReturnValue = "junction";
 
   if (pInComingCount <= 1 && pOutGoingCount > 1) {
@@ -112,10 +152,16 @@ function classifyForkJoin(pInComingCount, pOutGoingCount) {
   return lReturnValue;
 }
 
+/**
+ * @param {import("../../types/state-machine-cat.js").IStateMachine} pStateMachine
+ * @param {StateMachineModel} pFlattenedStateMachineModel
+ * @returns {import("../../types/state-machine-cat.js").IStateMachine}
+ */
 function classifyForkJoins(
   pStateMachine,
   pFlattenedStateMachineModel = new StateMachineModel(pStateMachine)
 ) {
+  // TODO: mutates parameter
   pStateMachine.states = pStateMachine.states.map((pState) => {
     if (pState.type === "forkjoin" && !pState.typeExplicitlySet) {
       const lInComingCount = pFlattenedStateMachineModel.findTransitionsByTo(
@@ -139,6 +185,11 @@ function classifyForkJoins(
   return pStateMachine;
 }
 
+/**
+ * @param {import("../../types/state-machine-cat.js").IState} pStateOne
+ * @param {import("../../types/state-machine-cat.js").IState} pStateTwo
+ * @returns {boolean}
+ */
 function stateEqual(pStateOne, pStateTwo) {
   return pStateOne.name === pStateTwo.name;
 }
@@ -158,12 +209,17 @@ function uniq(pArray, pEqualFunction) {
   }, []);
 }
 
+/**
+ * @param {String} pString
+ * @returns {{event?: string; cond?: string; action?: string}}
+ */
 function parseTransitionExpression(pString) {
   // eslint-disable-next-line security/detect-unsafe-regex, unicorn/no-unsafe-regex
   const lTransitionExpressionRe = /([^[/]+)?(\[[^\]]+\])?[^/]*(\/.+)?/;
   const lReturnValue = {};
 
-  // match has no fallback because lTransitionExpressionRe will match
+  /** @type {RegExpMatchArray} */
+  // @ts-expect-error match has no fallback because lTransitionExpressionRe will match
   // any string (every part is optional)
   const lMatchResult = pString.match(lTransitionExpressionRe);
   const lEventPos = 1;
@@ -195,6 +251,10 @@ function setIfNotEmpty(pObject, pProperty, pValue) {
   setIf(pObject, pProperty, pValue, (pX) => pX && pX.length > 0);
 }
 
+/**
+ * @param {string} pActivityCandidate
+ * @returns {{type: string; body: string}}
+ */
 function extractAction(pActivityCandidate) {
   const lMatch = pActivityCandidate.match(TRIGGER_RE);
   const lTypePos = 1;
@@ -212,6 +272,10 @@ function extractAction(pActivityCandidate) {
   };
 }
 
+/**
+ * @param {string} pString
+ * @returns {{type: string; body: string}[]}
+ */
 function extractActions(pString) {
   return pString
     .split(/\n\s*/g)

package/src/parse/scxml/index.mjs

@@ -4,7 +4,7 @@ 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";
+import { normalizeMachine } from "./normalize-machine.mjs";
 
 const formatLabel = utl.formatLabel;
 
@@ -26,6 +26,15 @@ function extractActionsFromInvokes(pInvokeTriggers) {
   });
 }
 
+/**
+ * @param {import("./scxml").INormalizedSCXMLState} pState
+ * @returns {{type: string; body: string;}[]}
+ */
+
+/**
+ * @param {import("./scxml").INormalizedSCXMLState} pState
+ * @returns {any[]}
+ */
 function deriveActions(pState) {
   let lReturnValue = [];
 
@@ -43,12 +52,24 @@ function deriveActions(pState) {
   return lReturnValue;
 }
 
+/**
+ * @param {import("../../..").StateType} pType
+ * param {import("./scxml").ISCXMLHistoryState} pState
+ * @param {any} pState
+ * @returns {import("../../..").StateType}
+ */
 function deriveStateType(pType, pState) {
   return pType === "history" && pState.type === "deep" ? "deephistory" : pType;
 }
 
+/**
+ * @param {import("../../../types/state-machine-cat").StateType} pType
+ * returns {(pState: import("./scxml").INormalizedSCXMLState) => import("../../..").IState}
+ * @returns {(any) => import("../../..").IState}
+ */
 function mapState(pType) {
   return (pState) => {
+    /** @type {import("../../../types/state-machine-cat").IState} */
     const lReturnValue = {
       name: pState.id,
       type: deriveStateType(pType, pState),
@@ -73,6 +94,10 @@ function mapState(pType) {
   };
 }
 
+/**
+ * @param {import("./scxml").ISCXMLTransition} pTransition
+ * @returns {{event?: string; cond?: string; action?: string; type?: string;}}
+ */
 function extractTransitionAttributesFromObject(pTransition) {
   const lReturnValue = {};
 
@@ -95,6 +120,11 @@ function extractTransitionAttributesFromObject(pTransition) {
   return lReturnValue;
 }
 
+/**
+ *
+ * @param {import("./scxml").ISCXMLTransition} pTransition
+ * @returns {{action?: string; label?: string;event?: string; cond?: string; type?: string}}
+ */
 function extractTransitionAttributes(pTransition) {
   const lReturnValue = {};
 
@@ -120,11 +150,19 @@ function extractTransitionAttributes(pTransition) {
   return lReturnValue;
 }
 
+/**
+ * @param {import("./scxml").INormalizedSCXMLState} pState
+ */
 function reduceTransition(pState) {
+  /**
+   * @param {import("./scxml").ISCXMLTransition[]} pAllTransitions
+   * @param {import("./scxml").ISCXMLTransition} pTransition
+   * @returns {import("../../..").ITransition}
+   */
   return (pAllTransitions, pTransition) => {
     // in SCXML spaces denote references to multiple states
     // => split into multiple transitions
-    const lTargets = (pTransition.target || pState.id).split(/\s+/);
+    const lTargets = (pTransition?.target ?? pState.id).split(/\s+/);
     const lTransitionAttributes = extractTransitionAttributes(pTransition);
 
     return pAllTransitions.concat(
@@ -139,6 +177,10 @@ function reduceTransition(pState) {
   };
 }
 
+/**
+ * @param {import("./scxml").INormalizedSCXMLState[]} pStates
+ * @returns {import("../../../types/state-machine-cat").ITransition[]}
+ */
 function extractTransitions(pStates) {
   return pStates
     .filter((pState) =>
@@ -156,20 +198,24 @@ function extractTransitions(pStates) {
     );
 }
 
-function mapMachine(pMachine) {
-  const lMachine = normalizeMachine(pMachine);
-  const lReturnValue = {};
-
-  lReturnValue.states = lMachine.initial
-    .map(mapState("initial"))
-    .concat(lMachine.state.map(mapState("regular")))
-    .concat(lMachine.parallel.map(mapState("parallel")))
-    .concat(lMachine.history.map(mapState("history")))
-    .concat(lMachine.final.map(mapState("final")));
+/**
+ * @param {any} pSCXMLStateMachine
+ * @returns {import("../../..").IStateMachine}
+ */
+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(lMachine.initial)
-    .concat(extractTransitions(lMachine.state))
-    .concat(extractTransitions(lMachine.parallel));
+  const lTransitions = extractTransitions(lNormalizedMachine.initial)
+    .concat(extractTransitions(lNormalizedMachine.state))
+    .concat(extractTransitions(lNormalizedMachine.parallel));
 
   if (lTransitions.length > 0) {
     lReturnValue.transitions = lTransitions;
@@ -181,20 +227,26 @@ function mapMachine(pMachine) {
  * Parses SCXML into a state machine AST.
  *
  * @param {string} pSCXMLString The SCXML to parse
- * @returns {IStateMachine} state machine AST
+ * @returns {import("../../../types/state-machine-cat").IStateMachine} state machine AST
  */
 export function parse(pSCXMLString) {
-  const lSCXMLString = pSCXMLString.trim();
+  const lTrimmedSCXMLString = pSCXMLString.trim();
 
-  if (fastxml.validate(lSCXMLString) === true) {
-    const lXMLAsJSON = fastxml.parse(lSCXMLString, {
+  if (fastxml.validate(lTrimmedSCXMLString) === true) {
+    /** @type {import("./scxml").ISCXMLAsJSON} */
+    const lXMLAsJSON = fastxml.parse(lTrimmedSCXMLString, {
       attributeNamePrefix: "",
       ignoreAttributes: false,
       tagValueProcessor: (pTagValue) => he.decode(pTagValue),
       stopNodes: ["onentry", "onexit", "transition"],
     });
 
-    return mapMachine(lXMLAsJSON?.scxml ?? {});
+    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/src/parse/scxml/normalize-machine.mjs

@@ -1,61 +1,67 @@
 import castArray from "lodash/castArray.js";
 
-function normalizeInitialFromObject(pMachine) {
+/**
+ * @param {Partial<import("./scxml").ISCXMLInitialState>} pInitialObject
+ * @param {string} [pId]
+ * @returns {import("./scxml").ISCXMLInitialState}
+ */
+function normalizeInitialFromObject(pInitialObject, pId) {
   const lReturnValue = {
     // ensure the 'initial' state has a unique name
-    id: pMachine.id ? `${pMachine.id}.initial` : "initial",
+    id: pId ? `${pId}.initial` : "initial",
   };
 
-  if (pMachine.initial.transition) {
+  if (pInitialObject.transition) {
     Object.assign(lReturnValue, {
-      transition: [pMachine.initial.transition],
+      transition: [pInitialObject.transition],
     });
   }
 
   return lReturnValue;
 }
 
-function normalizeInitialFromString(pMachine) {
+/**
+ * @param {string} pString
+ * @returns {import("./scxml").ISCXMLInitialState}
+ */
+function normalizeInitialFromString(pString) {
   return {
     id: "initial",
     transition: [
       {
-        target: pMachine.initial,
+        target: pString,
       },
     ],
   };
 }
 
+/**
+ * @param {any} pMachine
+ * @returns {import("./scxml").ISCXMLInitialState[]}
+ */
 function normalizeInitial(pMachine) {
   const lReturnValue = [];
-  let lInitialObject = {};
 
   if (pMachine.initial) {
-    // => it's an xml node. This detection isn't fool proof...;
-    // if it's a node but it doesn't have a transtion (which
-    // looks like an odd corner case) we won't recognize the
-    // initial
-    // the initial.id shouldn't occur (not allowed in scxml
-    // land), but smcat scxml renderer generates it nonetheless
-    if (pMachine.initial.transition || pMachine.initial.id) {
-      lInitialObject = normalizeInitialFromObject(pMachine);
+    if (typeof pMachine.initial === "string") {
+      lReturnValue.push(normalizeInitialFromString(pMachine.initial));
     } else {
-      lInitialObject = normalizeInitialFromString(pMachine);
+      lReturnValue.push(
+        normalizeInitialFromObject(pMachine.initial, pMachine.id)
+      );
     }
-    lReturnValue.push(lInitialObject);
   }
   return lReturnValue;
 }
 
 /**
  * Massages SCXML-as-json to be uniform:
- * -
  *
  * @param {any} pMachine SCXML-as-json state machine
- * @returns {any} Still an SCXML-as-json state machine, but more consistent and
- *                easier to use
+ * @returns {import("./scxml").INormalizedSCXMLMachine} Still an SCXML-as-json state machine,
+ * but more consistent and easier to use
  */
-export default function normalizeMachine(pMachine) {
+export function normalizeMachine(pMachine) {
   return {
     ...pMachine,
     initial: normalizeInitial(pMachine),