state-machine-cat 10.1.6 → 10.1.7

package/src/render/dot/render-dot-from-ast.js

@@ -1,70 +0,0 @@
-/** @type {any} - the Handlebars delivered types don't seem to cover everythint in handlebars ...*/
-const Handlebars = require("handlebars/dist/handlebars.runtime.js");
-// eslint-disable-next-line import/no-unassigned-import
-require("./dot.template.js");
-// eslint-disable-next-line import/no-unassigned-import
-require("./dot.states.template.js");
-
-Handlebars.registerPartial(
-  "dot.states.template.hbs",
-  Handlebars.templates["dot.states.template.hbs"]
-);
-
-Handlebars.registerHelper("stateSection", (pStateMachine) =>
-  // eslint-disable-next-line no-use-before-define
-  Handlebars.templates["dot.states.template.hbs"](splitStates(pStateMachine))
-);
-
-// TODO: duplicate from the one in state-transformers.js
-/**
- *
- * @param {string} pString
- * @returns {(pState: import("../../../types/state-machine-cat.js").IState) => Boolean}
- */
-function isType(pString) {
-  return (pState) => pState.type === pString;
-}
-/**
- *
- * @param {string[]} pStringArray
- * @returns {(pState: import("../../../types/state-machine-cat.js").IState) => Boolean}
- */
-// TODO: duplicate from the one in state-transformers.js
-function isOneOfTypes(pStringArray) {
-  return (pState) => pStringArray.includes(pState.type);
-}
-
-// TODO: duplicate from the one in index.js
-function splitStates(pStateMachine) {
-  pStateMachine.initialStates = pStateMachine.states.filter(isType("initial"));
-  pStateMachine.regularStates = pStateMachine.states.filter(
-    (pState) => isType("regular")(pState) && !pState.statemachine
-  );
-  pStateMachine.historyStates = pStateMachine.states.filter(isType("history"));
-  pStateMachine.deepHistoryStates = pStateMachine.states.filter(
-    isType("deephistory")
-  );
-  pStateMachine.choiceStates = pStateMachine.states.filter(isType("choice"));
-  pStateMachine.forkjoinStates = pStateMachine.states.filter(
-    isOneOfTypes(["fork", "join", "forkjoin"])
-  );
-  pStateMachine.junctionStates = pStateMachine.states.filter(
-    isType("junction")
-  );
-  pStateMachine.terminateStates = pStateMachine.states.filter(
-    isType("terminate")
-  );
-  pStateMachine.finalStates = pStateMachine.states.filter(isType("final"));
-  pStateMachine.compositeStates = pStateMachine.states.filter(
-    (pState) => pState.statemachine
-  );
-
-  return pStateMachine;
-}
-/**
- * @param {import("../../../types/state-machine-cat.js").IStateMachine} pStateMachine
- * @returns {string}
- */
-module.exports = function renderDotFromAST(pStateMachine) {
-  return Handlebars.templates["dot.template.hbs"](pStateMachine);
-};

package/src/render/dot/state-transformers.mjs

@@ -1,128 +0,0 @@
-import cloneDeep from "lodash/cloneDeep.js";
-import utl from "./utl.mjs";
-
-function isType(pString) {
-  return (pState) => pState.type === pString;
-}
-function isOneOfTypes(pStringArray) {
-  return (pState) => pStringArray.includes(pState.type);
-}
-
-function setLabel(pState) {
-  const lState = cloneDeep(pState);
-  lState.label = pState.label || pState.name;
-  return lState;
-}
-
-function nameNote(pState) {
-  if (Object.prototype.hasOwnProperty.call(pState, "note")) {
-    pState.noteName = `note_${pState.name}`;
-  }
-  return pState;
-}
-
-function classifyState(pState) {
-  const lClasses = ["state", pState.type];
-
-  if (Object.prototype.hasOwnProperty.call(pState, "class")) {
-    lClasses.push(pState.class.trim().replace(/[ ]{2,}/g, " "));
-  }
-
-  pState.class = lClasses.join(" ");
-  return pState;
-}
-
-function formatActionType(pString) {
-  return pString === "activity" ? "" : `${pString}/ `;
-}
-
-function flattenActions(pState) {
-  const lReturnValue = { ...pState };
-
-  if (pState.actions) {
-    lReturnValue.actions = pState.actions.map(
-      (pAction) => `${formatActionType(pAction.type)}${pAction.body}`
-    );
-  }
-
-  return lReturnValue;
-}
-function flattenNote(pState) {
-  if (Object.prototype.hasOwnProperty.call(pState, "note")) {
-    pState.noteFlattened = pState.note.join("");
-  }
-  return pState;
-}
-
-function recolor(pNodeAttributes) {
-  return (pState) => {
-    const lNodeColor = (pNodeAttributes || []).find(
-      (pAttribute) => pAttribute.name === "color"
-    )?.value;
-
-    if (
-      lNodeColor &&
-      !pState.color &&
-      isOneOfTypes([
-        "initial",
-        "fork",
-        "join",
-        "junction",
-        "forkjoin",
-        "final",
-      ])(pState)
-    ) {
-      pState.color = lNodeColor;
-    }
-    return pState;
-  };
-}
-
-function escapeStateStrings(pState) {
-  if (pState.note) {
-    pState.note = pState.note.map(utl.escapeString);
-  }
-  return pState;
-}
-
-function tipForkJoinStates(pDirection) {
-  return (pState) => {
-    if (isOneOfTypes(["fork", "join", "forkjoin"])(pState)) {
-      return {
-        sizingExtras: utl.isVertical(pDirection) ? "height=0.1" : "width=0.1",
-        ...pState,
-      };
-    }
-    return pState;
-  };
-}
-
-function flagParallelChildren(pState) {
-  if (
-    pState.type === "parallel" &&
-    pState.statemachine &&
-    pState.statemachine.states
-  ) {
-    pState.statemachine.states = pState.statemachine.states.map((pChildState) =>
-      isType("regular")(pChildState)
-        ? { ...pChildState, parentIsParallel: true }
-        : pChildState
-    );
-  }
-
-  return pState;
-}
-
-export default {
-  isType,
-  isOneOfTypes,
-  setLabel,
-  classifyState,
-  nameNote,
-  flattenActions,
-  flattenNote,
-  recolor,
-  escapeStateStrings,
-  tipForkJoinStates,
-  flagParallelChildren,
-};

package/src/render/dot/transition-transformers.mjs

@@ -1,52 +0,0 @@
-import utl from "./utl.mjs";
-
-function escapeTransitionStrings(pTransition) {
-  if (pTransition.note) {
-    pTransition.note = pTransition.note.map(utl.escapeString);
-  }
-  if (pTransition.label) {
-    pTransition.label = utl.escapeLabelString(pTransition.label);
-  }
-  return pTransition;
-}
-
-function addPorts(pDirection) {
-  return (pTransition) => {
-    let lAdditionalAttributes = {};
-
-    if (pTransition.isCompositeSelf) {
-      if (utl.isVertical(pDirection)) {
-        lAdditionalAttributes = {
-          tailportflags: `tailport="e" headport="e"`,
-          headportflags: `tailport="w"`,
-        };
-      } else if (pTransition.hasParent) {
-        lAdditionalAttributes = {
-          tailportflags: `tailport="n" headport="n"`,
-          headportflags: `tailport="s"`,
-        };
-      } else {
-        lAdditionalAttributes = {
-          tailportflags: `tailport="s" headport="s"`,
-          headportflags: `tailport="n"`,
-        };
-      }
-    }
-    return { ...pTransition, ...lAdditionalAttributes };
-  };
-}
-
-function classifyTransition(pTransition) {
-  let lClasses = ["transition"];
-  if (pTransition.type) {
-    lClasses.push(pTransition.type);
-  }
-  if (pTransition.class) {
-    lClasses.push(pTransition.class.trim().replace(/[ ]{2,}/g, " "));
-  }
-
-  pTransition.class = lClasses.join(" ");
-  return pTransition;
-}
-
-export default { escapeTransitionStrings, addPorts, classifyTransition };

package/src/render/dot/utl.mjs

@@ -1,56 +0,0 @@
-// @ts-check
-
-/**
- * @param {string} pString
- * @returns {string}
- */
-function escapeString(pString) {
-  return pString
-    .replace(/\\/g, "\\\\")
-    .replace(/\n\s*/g, "\\l")
-    .replace(/"/g, '\\"')
-    .concat("\\l");
-}
-
-/**
- * @param {string} pString
- * @returns {string}
- */
-function escapeLabelString(pString) {
-  return pString
-    .replace(/\\/g, "\\\\")
-    .replace(/\n\s*/g, "   \\l")
-    .replace(/"/g, '\\"')
-    .concat("   \\l");
-}
-
-/**
- * @param {string} pDirection
- * @returns {boolean}
- */
-function isVertical(pDirection) {
-  const lDirection = pDirection || "top-down";
-
-  return lDirection === "top-down" || lDirection === "bottom-top";
-}
-
-/**
- *
- * @param {import("../../state-machine-model.mjs").default} pStateMachineModel
- * @param {import("../../../types/state-machine-cat").ITransition} pTransition
- * @returns {boolean}
- */
-function isCompositeSelf(pStateMachineModel, pTransition) {
-  return (
-    pTransition.from === pTransition.to &&
-    pStateMachineModel.findStateByName(pTransition.from).statemachine &&
-    !(pTransition.type === "internal")
-  );
-}
-
-export default {
-  escapeString,
-  escapeLabelString,
-  isVertical,
-  isCompositeSelf,
-};

package/src/render/index-node.mjs

@@ -1,36 +0,0 @@
-// @ts-check
-/* eslint-disable security/detect-object-injection */
-import has from "lodash/has.js";
-import smcat from "./smcat/index.js";
-import dot from "./dot/index.mjs";
-import vector from "./vector/vector-native-dot-with-fallback.mjs";
-import oldVector from "./vector/vector-with-viz-js.mjs";
-import scjson from "./scjson/index.mjs";
-import scxml from "./scxml/index.mjs";
-
-/**
- *
- * @param {import("../../types/state-machine-cat.js").OutputType} pOutputType
- * @returns {import("../../types/state-machine-cat.js").RenderFunctionType}
- */
-export default function getRenderFunction(pOutputType) {
-  const lOutputType2RenderFunction = {
-    smcat,
-    dot,
-    svg: vector,
-    eps: vector,
-    ps: vector,
-    ps2: vector,
-    oldsvg: oldVector,
-    oldps2: oldVector,
-    oldeps: oldVector,
-    pdf: vector,
-    png: vector,
-    scjson,
-    scxml,
-  };
-
-  return has(lOutputType2RenderFunction, pOutputType)
-    ? lOutputType2RenderFunction[pOutputType]
-    : (pX) => pX;
-}

package/src/render/index.mjs

@@ -1,22 +0,0 @@
-/* eslint-disable security/detect-object-injection */
-import has from "lodash/has.js";
-import smcat from "./smcat/index.js";
-import dot from "./dot/index.mjs";
-import svg from "./vector/vector-with-viz-js.mjs";
-import scjson from "./scjson/index.mjs";
-import scxml from "./scxml/index.mjs";
-
-export default function getRenderFunction(pOutputType) {
-  const lOutputType2RenderFunction = {
-    smcat,
-    dot,
-    svg,
-    oldsvg: svg,
-    scjson,
-    scxml,
-  };
-
-  return has(lOutputType2RenderFunction, pOutputType)
-    ? lOutputType2RenderFunction[pOutputType]
-    : (pX) => pX;
-}

package/src/render/scjson/index.mjs

@@ -1,175 +0,0 @@
-/* eslint-disable security/detect-object-injection */
-import StateMachineModel from "../../state-machine-model.mjs";
-import makeValidXMLName from "./make-valid-xml-name.mjs";
-import makeValidEventNames from "./make-valid-event-names.mjs";
-
-const STATE_TYPE2SCXML_STATE_KIND = {
-  regular: "state",
-  initial: "initial",
-  final: "final",
-  terminate: "final",
-  parallel: "parallel",
-  history: "history",
-  deephistory: "history",
-};
-
-function stateType2SCXMLStateKind(pStateType) {
-  return STATE_TYPE2SCXML_STATE_KIND[pStateType] || "state";
-}
-
-function transformTransition(pTransition) {
-  const lReturnValue = {
-    target: makeValidXMLName(pTransition.to),
-  };
-
-  if (Boolean(pTransition.event)) {
-    lReturnValue.event = makeValidEventNames(pTransition.event);
-  }
-  if (Boolean(pTransition.cond)) {
-    lReturnValue.cond = pTransition.cond;
-  }
-  if (Boolean(pTransition.action)) {
-    lReturnValue.action = pTransition.action;
-  }
-  if (Boolean(pTransition.type)) {
-    lReturnValue.type = pTransition.type;
-  }
-  return lReturnValue;
-}
-
-function extractTriggers(pTriggers, pTriggerType) {
-  return pTriggers
-    .filter((pTrigger) => pTrigger.type === pTriggerType)
-    .map((pTrigger) => pTrigger.body);
-}
-
-function pullOutActionType(pReturnValue, pTriggersType, pActions, pActionType) {
-  const lTriggerArray = extractTriggers(pActions, pActionType);
-
-  if (lTriggerArray.length > 0) {
-    pReturnValue[pTriggersType] = (pReturnValue[pTriggersType] || []).concat(
-      lTriggerArray
-    );
-  }
-}
-
-function transformTriggers(pReturnValue, pState) {
-  if (Boolean(pState.actions)) {
-    pullOutActionType(pReturnValue, "onentries", pState.actions, "entry");
-    pullOutActionType(pReturnValue, "onentries", pState.actions, "activity");
-    pullOutActionType(pReturnValue, "onexits", pState.actions, "exit");
-  }
-}
-
-function transformTransitions(pReturnValue, pState, pTransitions) {
-  const lTransitions = pTransitions
-    .filter((pTransition) => pTransition.from === pState.name)
-    .map(transformTransition);
-
-  if (lTransitions.length > 0) {
-    pReturnValue.transitions = lTransitions;
-  }
-}
-
-function transformCompositeState(pReturnValue, pState, pTransitions) {
-  if (Boolean(pState.statemachine)) {
-    // recursion, so ...
-    // eslint-disable-next-line no-use-before-define
-    const lRenderedState = render(pState.statemachine, null, pTransitions);
-
-    pReturnValue.states = (pReturnValue.states || []).concat(
-      lRenderedState.states
-    );
-    if (lRenderedState.initial) {
-      pReturnValue.initial = lRenderedState.initial;
-    }
-  }
-}
-
-function transformState(pTransitions) {
-  pTransitions = pTransitions || [];
-
-  return (pState) => {
-    const lReturnValue = {
-      kind: stateType2SCXMLStateKind(pState.type),
-      id: makeValidXMLName(pState.name),
-    };
-
-    if (pState.type === "deephistory") {
-      // as 'shallow' is the default anyway, we leave it out
-      lReturnValue.type = "deep";
-    }
-
-    transformTriggers(lReturnValue, pState);
-
-    transformTransitions(lReturnValue, pState, pTransitions);
-
-    transformCompositeState(lReturnValue, pState, pTransitions);
-    return lReturnValue;
-  };
-}
-
-function findInitialPseudoStateName(pStateMachine) {
-  let lReturnValue = null;
-
-  const lInitial = pStateMachine.states.filter(
-    (pState) => pState.type === "initial"
-  );
-
-  if (lInitial.length > 0) {
-    lReturnValue = lInitial[0].name;
-  }
-  return lReturnValue;
-}
-
-function findInitialStateName(pStateMachine, pInitialPseudoStateName) {
-  let lReturnValue = pInitialPseudoStateName;
-
-  if (pInitialPseudoStateName && pStateMachine.transitions) {
-    const lInitialTransitions = pStateMachine.transitions.filter(
-      (pTransition) => pTransition.from === pInitialPseudoStateName
-    );
-
-    if (lInitialTransitions.length > 0 && !lInitialTransitions[0].action) {
-      lReturnValue = lInitialTransitions[0].to;
-    }
-  }
-  return lReturnValue;
-}
-
-/**
- * @param {import("../../..").IStateMachine} pStateMachine
- * @param {import("../../..").IRenderOptions} [_pOptions]
- * @param {import("../../..").ITransition[]} [pTransitions] (no need to specify - used in recursion)
- * @returns {any} TODO: scjson data structure
- */
-export default function render(pStateMachine, _pOptions, pTransitions) {
-  const lInitialPseudoStateName = findInitialPseudoStateName(pStateMachine);
-  const lInitialStateName = findInitialStateName(
-    pStateMachine,
-    lInitialPseudoStateName
-  );
-  const lReturnValue = {
-    states: pStateMachine.states
-      .filter((pState) => {
-        if (
-          lInitialStateName &&
-          lInitialStateName !== lInitialPseudoStateName
-        ) {
-          return pState.type !== "initial";
-        }
-        return true;
-      })
-      .map(
-        transformState(
-          pTransitions ||
-            new StateMachineModel(pStateMachine).flattenedTransitions
-        )
-      ),
-  };
-
-  if (lInitialStateName) {
-    lReturnValue.initial = makeValidXMLName(lInitialStateName);
-  }
-  return lReturnValue;
-}

package/src/render/scjson/make-valid-event-names.mjs

@@ -1,71 +0,0 @@
-/*
- * In the XML spec we read: https://www.w3.org/TR/xml/#NT-Name:
- *
- * NameStartChar ::= ":" | [A-Z] | "_" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] | [#x370-#x37D] |
- *                   [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] |
- *                   [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
- * NameChar      ::= NameStartChar | "-" | "." | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]
- * Name          ::= NameStartChar (NameChar)*
- *
- * This means that these characters are forbidden for NameStartChar
- * #xD7, #xF7, #x300 - #x36F, #x37E, #x2000 - #x200B, #x200E - #x206F, #x2190 - #x2BFF, #x2FF0 - #x3000,
- * #xD800 - #xF8FF, #xFDD0 - #xFDEF, #xFFFE - #xFFFF
- */
-
-/* eslint no-control-regex: 0, max-len: 0, no-misleading-character-class: 0 */
-//  EVENT_CHAR_FORBIDDEN_RE === forbidden for NameStartChar, except "-" and [0-9]
-// The SCXML xsd doesn't seem to mention '*' (\u002A) as an allowed character. But
-// they _are_ used in event descriptors in the SCXML spec. So we've excluded
-// them from forbidden characters
-const EVENT_CHAR_FORBIDDEN_RE =
-  /[\u00B7|\u0300-\u036F|\u203F-\u2040|\u0000-\u0029|\u002B-\u002C|\u002F|\u003B-\u0040|\u005B-\u0060|\u007B-\u00BF|\u00D7|\u00F7|\u0300-\u036F|\u037E|\u2000-\u200B|\u200E-\u206F|\u2190-\u2BFF|\u2FF0-\u3000|\uD800-\uF8FF|\uFDD0-\uFDEF|\uFFFE-\uFFFF]/g;
-const START_EVENT_CHAR_FORBIDDEN_EXTRA_RE = /[.]/g;
-
-function makeValidEventChar(pCandidateEventStringTail) {
-  return pCandidateEventStringTail.replace(EVENT_CHAR_FORBIDDEN_RE, "_");
-}
-
-function makeValidEventStartChar(pCandidateEventStringStart) {
-  let lReturnValue = makeValidEventChar(pCandidateEventStringStart);
-
-  if (lReturnValue.match(START_EVENT_CHAR_FORBIDDEN_EXTRA_RE)) {
-    lReturnValue = `_${pCandidateEventStringStart}`;
-  }
-  return lReturnValue;
-}
-
-function makeValidEventName(pCandidateEventName) {
-  pCandidateEventName = pCandidateEventName.replace(/\s+/g, " ").trim();
-
-  return makeValidEventStartChar(pCandidateEventName[0]).concat(
-    makeValidEventChar(pCandidateEventName.slice(1))
-  );
-}
-/**
- * Takes any string and returns a valid SCXML events string:
- *
- * If pCandidateName is not empty:
- *   For all characters in pCandidateName:
- *    if it's not a valid NameChar, replace it with '_'
- *   For the first character:
- *     If it's a valid NameChar, but not a valid NameStartChar, add an '_' in front of the pCandidateName
- *
- * If pCandidateName is empty:
- *  return the strling 'empty'
- * *
- * @param {string[]} pCandidateEventNames (optional)
- * @returns {string} a valid SCXML events string
- */
-export default (pCandidateEventNames) => {
-  pCandidateEventNames = pCandidateEventNames || "";
-
-  if (pCandidateEventNames.length === 0) {
-    return "empty";
-  }
-
-  return pCandidateEventNames
-    .split(/[\n\r]+/)
-    .filter((pCandidateEventName) => pCandidateEventName.length > 0)
-    .map(makeValidEventName)
-    .join(" ");
-};

package/src/render/scjson/make-valid-xml-name.mjs

@@ -1,70 +0,0 @@
-// @ts-check
-/*
- * In the XML spec we read: https://www.w3.org/TR/xml/#NT-Name:
- *
- * NameStartChar ::= ":" | [A-Z] | "_" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] | [#x370-#x37D] |
- *                   [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] |
- *                   [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
- * NameChar      ::= NameStartChar | "-" | "." | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]
- * Name          ::= NameStartChar (NameChar)*
- *
- * This means that these characters are forbidden for NameStartChar
- * #xD7, #xF7, #x300 - #x36F, #x37E, #x2000 - #x200B, #x200E - #x206F, #x2190 - #x2BFF, #x2FF0 - #x3000,
- * #xD800 - #xF8FF, #xFDD0 - #xFDEF, #xFFFE - #xFFFF
- */
-
-/* eslint no-control-regex: 0, max-len: 0, no-misleading-character-class: 0 */
-const NAME_CHAR_FORBIDDEN_RE =
-  /[\u0000-\u002C|\u002F|\u003B-\u0040|\u005B-\u0060|\u007B-\u00BF|\u00D7|\u00F7|\u0300-\u036F|\u037E|\u2000-\u200B|\u200E-\u206F|\u2190-\u2BFF|\u2FF0-\u3000|\uD800-\uF8FF|\uFDD0-\uFDEF|\uFFFE-\uFFFF]/g;
-const START_NAME_CHAR_FORBIDDEN_EXTRA_RE =
-  /[-|.|0-9|\u00B7|\u0300-\u036F|\u203F-\u2040]/g;
-
-/**
- *
- * @param {string} pCandidateNameTail
- * @returns {string}
- */
-function makeValidNameChars(pCandidateNameTail) {
-  return pCandidateNameTail.replace(NAME_CHAR_FORBIDDEN_RE, "_");
-}
-
-/**
- * if it's an invalid NameStartChar but a valid NameChar smack a '_' in front of it
- * if it's an invalid NameChar as well - run it through the makeValidNameChars replacer
- * @param {string} pCandidateChar - start char
- * @returns {string} valid start string
- */
-function makeValidNameStartChar(pCandidateChar) {
-  let lReturnValue = makeValidNameChars(pCandidateChar);
-
-  if (lReturnValue.match(START_NAME_CHAR_FORBIDDEN_EXTRA_RE)) {
-    lReturnValue = `_${pCandidateChar}`;
-  }
-  return lReturnValue;
-}
-
-/**
- * Takes any string and returns a valid XMLName using these rules:
- *
- * If pCandidateName is not empty:
- *   For all characters in pCandidateName:
- *    if it's not a valid NameChar, replace it with '_'
- *   For the first character:
- *     If it's a valid NameChar, but not a valid NameStartChar, add an '_' in front of the pCandidateName
- *
- * If pCandidateName is empty:
- *  return the string '__empty'
- * *
- * @param {string} pCandidateName (optional)
- * @returns {string} a valid XMLName
- */
-export default (pCandidateName) => {
-  pCandidateName = pCandidateName || "";
-
-  if (pCandidateName.length === 0) {
-    return `__empty`;
-  }
-  return makeValidNameStartChar(pCandidateName[0]).concat(
-    makeValidNameChars(pCandidateName.slice(1))
-  );
-};

package/src/render/scxml/index.mjs

@@ -1,8 +0,0 @@
-// @ts-check
-import ast2scjson from "../scjson/index.mjs";
-import renderFomSCJSON from "./render-from-scjson.js";
-
-/** @type {import("../../..").StringRenderFunctionType} */
-export default function renderSCXML(pStateMachine) {
-  return renderFomSCJSON(ast2scjson(pStateMachine));
-}