state-machine-cat 13.0.2 → 14.0.0

package/README.md

@@ -125,10 +125,10 @@ of thing you can read all about it in [State Machine Cat and SCXML](./docs/SCXML
 After you `npm i` 'd `state-machine-cat`:
 
 ```javascript
-import smcat from "state-machine-cat";
+import { render } from "state-machine-cat";
 
 try {
-  const lSVGInAString = smcat.render(
+  const lSVGInAString = await render(
     `
             initial => backlog;
             backlog => doing;
@@ -638,7 +638,7 @@ The values you can use for the `type` of a state:
 #### grammar
 
 I made the parser with peggy - you can find it at
-[src/parse/peg/smcat-parser.peggy](src/parse/smcat/peg/smcat-parser.peggy), and
+[src/parse/smcat-parser.peggy](src/parse/smcat/smcat-parser.peggy), and
 railroad diagrams generated from these on [state-machine-cat.js.org/grammar.html](https://state-machine-cat.js.org/grammar.html)
 
 ## Status

package/dist/cli/actions.mjs

@@ -1,4 +1,4 @@
-import smcat from "../index-node.mjs";
+import { render } from "../index-node.mjs";
 import { getOutStream, getInStream } from "./file-name-to-stream.mjs";
 const LICENSE = `
     state machine cat - write beautiful state charts
@@ -44,8 +44,8 @@ export function displayLicense(pOutStream) {
 	pOutStream.write(LICENSE, "utf8");
 }
 export function transform(pOptions) {
-	return getStream(getInStream(pOptions.inputFrom)).then((pInput) => {
-		const lOutput = smcat.render(pInput, {
+	return getStream(getInStream(pOptions.inputFrom)).then(async (pInput) => {
+		const lOutput = await render(pInput, {
 			inputType: pOptions.inputType,
 			outputType: pOptions.outputType,
 			engine: pOptions.engine,

package/dist/cli/cli.mjs

@@ -2,7 +2,18 @@ import { parseArgs } from "node:util";
 import { version } from "../version.mjs";
 import { formatError, displayLicense, transform } from "./actions.mjs";
 import normalize from "./normalize.mjs";
-import validations from "./validations.mjs";
+import {
+	validOutputType,
+	validInputType,
+	validEngine,
+	validDirection,
+	validDotAttrs,
+	validateArguments,
+	defaultOutputType,
+	defaultInputType,
+	defaultEngine,
+	defaultDirection,
+} from "./validations.mjs";
 const HELP_TEXT = `Usage: smcat [options] [infile]
 
 Write beautiful state charts - https://github.com/sverweij/state-machine-cat
@@ -51,22 +62,22 @@ function parseArguments(pArguments) {
 		"output-type": {
 			type: "string",
 			short: "T",
-			default: validations.defaultOutputType,
+			default: defaultOutputType,
 		},
 		"input-type": {
 			type: "string",
 			short: "I",
-			default: validations.defaultInputType,
+			default: defaultInputType,
 		},
 		engine: {
 			type: "string",
 			short: "E",
-			default: validations.defaultEngine,
+			default: defaultEngine,
 		},
 		direction: {
 			type: "string",
 			short: "d",
-			default: validations.defaultDirection,
+			default: defaultDirection,
 		},
 		"output-to": {
 			type: "string",
@@ -108,22 +119,16 @@ function parseArguments(pArguments) {
 		allowPositionals: true,
 		tokens: false,
 	});
-	values["output-type"] = validations.validOutputType(values["output-type"]);
-	values["input-type"] = validations.validInputType(values["input-type"]);
-	values.engine = validations.validEngine(values.engine);
-	values.direction = validations.validDirection(values.direction);
+	values["output-type"] = validOutputType(values["output-type"]);
+	values["input-type"] = validInputType(values["input-type"]);
+	values.engine = validEngine(values.engine);
+	values.direction = validDirection(values.direction);
 	if (values["dot-graph-attrs"])
-		values["dot-graph-attrs"] = validations.validDotAttrs(
-			values["dot-graph-attrs"],
-		);
+		values["dot-graph-attrs"] = validDotAttrs(values["dot-graph-attrs"]);
 	if (values["dot-node-attrs"])
-		values["dot-node-attrs"] = validations.validDotAttrs(
-			values["dot-node-attrs"],
-		);
+		values["dot-node-attrs"] = validDotAttrs(values["dot-node-attrs"]);
 	if (values["dot-edge-attrs"])
-		values["dot-edge-attrs"] = validations.validDotAttrs(
-			values["dot-edge-attrs"],
-		);
+		values["dot-edge-attrs"] = validDotAttrs(values["dot-edge-attrs"]);
 	return { values: camelizeObject(values), positionals };
 }
 export default async function cli(pArguments = process.argv, pOptions) {
@@ -146,9 +151,7 @@ export default async function cli(pArguments = process.argv, pOptions) {
 			displayLicense(lOptions.outStream);
 			return;
 		}
-		await transform(
-			validations.validateArguments(normalize(positionals[0], values)),
-		);
+		await transform(validateArguments(normalize(positionals[0], values)));
 	} catch (pError) {
 		presentError(pError, lOptions.errorStream);
 	}

package/dist/cli/normalize.mjs

@@ -1,5 +1,5 @@
 import path from "node:path";
-import options from "../options.mjs";
+import { getAllowedValues } from "../options.mjs";
 import { parse as parseAttributes } from "./attributes-parser.mjs";
 const INPUT_EXTENSIONS = {
 	".smcat": "smcat",
@@ -58,7 +58,7 @@ function determineInputType(pInputFrom, pInputType) {
 	return classifyExtension(
 		pInputFrom,
 		INPUT_EXTENSIONS,
-		options.getAllowedValues().inputType.default,
+		getAllowedValues().inputType.default,
 	);
 }
 function determineOutputType(pOutputTo, pOutputType) {
@@ -69,15 +69,15 @@ function determineOutputType(pOutputTo, pOutputType) {
 		return classifyExtension(
 			pOutputTo,
 			OUTPUT_EXTENSIONS,
-			options.getAllowedValues().outputType.default,
+			getAllowedValues().outputType.default,
 		);
 	}
-	return options.getAllowedValues().outputType.default;
+	return getAllowedValues().outputType.default;
 }
 function determineParameter(pOptions, pParameter) {
 	return Object.hasOwn(pOptions, pParameter)
 		? pOptions[pParameter]
-		: options.getAllowedValues()[pParameter].default;
+		: getAllowedValues()[pParameter].default;
 }
 function determineDotAttributes(pOptions, pDotAttributes) {
 	return pOptions?.[pDotAttributes] &&

package/dist/cli/validations.mjs

@@ -1,7 +1,7 @@
-import fs from "node:fs";
-import smcat from "../index-node.mjs";
+import { accessSync, constants } from "node:fs";
+import { getAllowedValues } from "../index-node.mjs";
 import { parse as parseAttributes } from "./attributes-parser.mjs";
-const allowedValues = smcat.getAllowedValues();
+const allowedValues = getAllowedValues();
 function getName(pValue) {
 	return pValue.name;
 }
@@ -15,7 +15,7 @@ function isStdout(pFilename) {
 function fileExists(pFilename) {
 	try {
 		if (!isStdout(pFilename)) {
-			fs.accessSync(pFilename, fs.constants.R_OK);
+			accessSync(pFilename, constants.R_OK);
 		}
 		return true;
 	} catch (pError) {
@@ -28,63 +28,61 @@ function validOption(pOption, pValidValues, pError) {
 	}
 	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,
+export const 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`,
+	);
+export const 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`,
+	);
+export const 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`,
+	);
+export const validDirection = (pDirection) =>
+	validOption(
+		pDirection,
+		VALID_DIRECTIONS,
+		`\n  error: '${pDirection}' is not a valid direction.` +
+			`\n         you can choose from ${VALID_DIRECTIONS.join(", ")}\n\n`,
+	);
+export const validDotAttrs = (pDotAttributes) => {
+	try {
+		parseAttributes(pDotAttributes);
+		return pDotAttributes;
+	} catch (pError) {
+		throw new Error(`Invalid dot attributes: ${pError.message}`);
+	}
+};
+export const 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;
 };
+export const validOutputTypeRE = VALID_OUTPUT_TYPES.join("|");
+export const defaultOutputType = allowedValues.outputType.default;
+export const validInputTypeRE = VALID_INPUT_TYPES.join("|");
+export const defaultInputType = allowedValues.inputType.default;
+export const validEngineRE = VALID_ENGINES.join("|");
+export const defaultEngine = allowedValues.engine.default;
+export const validDirectionRE = VALID_DIRECTIONS.join("|");
+export const defaultDirection = allowedValues.direction.default;

package/dist/index-node.mjs

@@ -1,19 +1,23 @@
-import options from "./options.mjs";
-import parse from "./parse/index.mjs";
+import {
+	getAllowedValues as _getAllowedValues,
+	getOptionValue,
+} from "./options.mjs";
+import { getAST } 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();
-	},
-};
+import { version as _version } from "./version.mjs";
+export async function render(pScript, pOptions) {
+	const lStateMachine = await getAST(pScript, pOptions);
+	const lDesugar = getOptionValue(pOptions, "desugar");
+	const lRenderFunction = await getRenderFunction(
+		getOptionValue(pOptions, "outputType"),
+	);
+	return lRenderFunction(
+		lDesugar ? desugar(lStateMachine) : lStateMachine,
+		pOptions,
+	);
+}
+export const version = _version;
+export function getAllowedValues() {
+	return _getAllowedValues();
+}

package/dist/index.mjs

@@ -1,23 +1,31 @@
-import options from "./options.mjs";
-import parse from "./parse/index.mjs";
-import desugar from "./transform/desugar.mjs";
+import {
+	getAllowedValues as _getAllowedValues,
+	getOptionValue,
+} from "./options.mjs";
+import { getAST } from "./parse/index.mjs";
 import getRenderFunction from "./render/index.mjs";
 import { version as _version } from "./version.mjs";
-export function render(pScript, pOptions) {
+let gDesugarModule = null;
+async function desugar(pStateMachine) {
+	if (!gDesugarModule) {
+		gDesugarModule = await import("./transform/desugar.mjs");
+	}
+	const lDesugarFunction = gDesugarModule.default;
+	return lDesugarFunction(pStateMachine);
+}
+export async function render(pScript, pOptions) {
 	const lOptions = pOptions ?? {};
-	const lStateMachine = parse.getAST(pScript, lOptions);
-	const lDesugar = options.getOptionValue(lOptions, "desugar");
-	return getRenderFunction(options.getOptionValue(lOptions, "outputType"))(
-		lDesugar ? desugar(lStateMachine) : lStateMachine,
+	const lStateMachine = await getAST(pScript, lOptions);
+	const lDesugar = getOptionValue(lOptions, "desugar");
+	const lRenderFunction = await getRenderFunction(
+		getOptionValue(lOptions, "outputType"),
+	);
+	return lRenderFunction(
+		lDesugar ? await desugar(lStateMachine) : lStateMachine,
 		lOptions,
 	);
 }
 export const version = _version;
 export function getAllowedValues() {
-	return options.getAllowedValues();
+	return _getAllowedValues();
 }
-export default {
-	render,
-	version,
-	getAllowedValues,
-};

package/dist/options.mjs

@@ -55,7 +55,3 @@ export function getOptionValue(pOptions, pOptionName) {
 export function getAllowedValues() {
 	return ALLOWED_VALUES;
 }
-export default {
-	getAllowedValues,
-	getOptionValue,
-};

package/dist/parse/index.mjs

@@ -1,27 +1,26 @@
 import Ajv from "ajv";
-import options from "../options.mjs";
+import { getOptionValue } from "../options.mjs";
 import { parse as parseSmCat } from "./smcat/parse.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)) {
+const validate = ajv.compile($schema);
+const parseSCXML = async (pScript) => {
+	const { parse } = await import("./scxml/index.mjs");
+	return parse(pScript);
+};
+export async function getAST(pScript, pOptions) {
+	let lReturnValue = pScript;
+	if (getOptionValue(pOptions, "inputType") === "smcat") {
+		lReturnValue = parseSmCat(pScript);
+	} else if (getOptionValue(pOptions, "inputType") === "scxml") {
+		lReturnValue = await parseSCXML(pScript);
+	} else if (typeof pScript === "string") {
+		lReturnValue = JSON.parse(pScript);
+	}
+	if (!validate(lReturnValue)) {
 		throw new Error(
 			`The provided JSON is not a valid state-machine-cat AST: ${ajv.errorsText()}.\n`,
 		);
 	}
+	return lReturnValue;
 }
-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/parse/parser-helpers.mjs

@@ -38,11 +38,11 @@ const RE2STATE_TYPE = [
 function matches(pName) {
 	return (pEntry) => pEntry.re.test(pName);
 }
-function getStateType(pName) {
+export function getStateType(pName) {
 	return (RE2STATE_TYPE.find(matches(pName)) || { stateType: "regular" })
 		.stateType;
 }
-function initState(pName) {
+export function initState(pName) {
 	return {
 		name: pName,
 		type: getStateType(pName),
@@ -59,27 +59,27 @@ function getAlreadyDeclaredStates(pStateMachine) {
 		lStates.map(({ name }) => name),
 	);
 }
-function extractUndeclaredStates(pStateMachine, pKnownStateNames) {
+export function extractUndeclaredStates(pStateMachine, 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,
+	for (const lState of pStateMachine.states.filter(isComposite)) {
+		lState.statemachine.states = extractUndeclaredStates(
+			lState.statemachine,
 			pKnownStateNames,
 		);
-	});
-	lTransitions.forEach((pTransition) => {
-		if (!stateExists(pKnownStateNames, pTransition.from)) {
-			pKnownStateNames.push(pTransition.from);
-			pStateMachine.states.push(initState(pTransition.from));
+	}
+	for (const lTransition of lTransitions) {
+		if (!stateExists(pKnownStateNames, lTransition.from)) {
+			pKnownStateNames.push(lTransition.from);
+			pStateMachine.states.push(initState(lTransition.from));
 		}
-		if (!stateExists(pKnownStateNames, pTransition.to)) {
-			pKnownStateNames.push(pTransition.to);
-			pStateMachine.states.push(initState(pTransition.to));
+		if (!stateExists(pKnownStateNames, lTransition.to)) {
+			pKnownStateNames.push(lTransition.to);
+			pStateMachine.states.push(initState(lTransition.to));
 		}
-	});
+	}
 	return pStateMachine.states;
 }
 function classifyForkJoin(pInComingCount, pOutGoingCount) {
@@ -92,7 +92,7 @@ function classifyForkJoin(pInComingCount, pOutGoingCount) {
 	}
 	return lReturnValue;
 }
-function classifyForkJoins(
+export function classifyForkJoins(
 	pStateMachine,
 	pFlattenedStateMachineModel = new StateMachineModel(pStateMachine),
 ) {
@@ -116,10 +116,10 @@ function classifyForkJoins(
 	});
 	return pStateMachine;
 }
-function stateEqual(pStateOne, pStateTwo) {
+export function stateEqual(pStateOne, pStateTwo) {
 	return pStateOne.name === pStateTwo.name;
 }
-function uniq(pArray, pEqualFunction) {
+export function uniq(pArray, pEqualFunction) {
 	return pArray.reduce((pBag, pMarble) => {
 		const lMarbleIndex = pBag.findIndex((pBagItem) =>
 			pEqualFunction(pBagItem, pMarble),
@@ -131,7 +131,7 @@ function uniq(pArray, pEqualFunction) {
 		return pBag.concat(pMarble);
 	}, []);
 }
-function parseTransitionExpression(pString) {
+export function parseTransitionExpression(pString) {
 	const lTransitionExpressionRe = /([^[/]+)?(\[[^\]]+\])?[^/]*(\/.+)?/;
 	const lReturnValue = {};
 	const lMatchResult = lTransitionExpressionRe.exec(pString);
@@ -151,12 +151,12 @@ function parseTransitionExpression(pString) {
 	}
 	return lReturnValue;
 }
-function setIf(pObject, pProperty, pValue, pCondition = Boolean) {
+export function setIf(pObject, pProperty, pValue, pCondition = Boolean) {
 	if (pCondition(pValue)) {
 		pObject[pProperty] = pValue;
 	}
 }
-function setIfNotEmpty(pObject, pProperty, pValue) {
+export function setIfNotEmpty(pObject, pProperty, pValue) {
 	setIf(pObject, pProperty, pValue, (pX) => pX && pX.length > 0);
 }
 function extractAction(pActivityCandidate) {
@@ -174,21 +174,9 @@ function extractAction(pActivityCandidate) {
 		body: pActivityCandidate,
 	};
 }
-function extractActions(pString) {
+export 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/parse/scxml/index.mjs

@@ -2,11 +2,10 @@ import { XMLParser } from "fast-xml-parser";
 import he from "he";
 import traverse from "neotraverse";
 import { Counter } from "../../counter.mjs";
-import parserHelpers from "../parser-helpers.mjs";
-import utl from "../../transform/utl.mjs";
+import { getStateType } from "../parser-helpers.mjs";
+import { formatLabel } from "../../transform/utl.mjs";
 import { castArray } from "./utl.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",
@@ -46,7 +45,7 @@ function mapState(pType) {
 			name: pState.id,
 			type: deriveStateType(pType, pState),
 		};
-		if (parserHelpers.getStateType(pState.id) !== lReturnValue.type) {
+		if (getStateType(pState.id) !== lReturnValue.type) {
 			lReturnValue.typeExplicitlySet = true;
 		}
 		if (pState.onentry || pState.onexit || pState.invoke) {

package/dist/parse/smcat/smcat-parser.mjs

@@ -1,4 +1,14 @@
-import parserHelpers from "../parser-helpers.mjs";
+import {
+	classifyForkJoins,
+	extractActions,
+	extractUndeclaredStates,
+	initState,
+	parseTransitionExpression,
+	setIf,
+	setIfNotEmpty,
+	stateEqual,
+	uniq,
+} from "../parser-helpers.mjs";
 class peg$SyntaxError extends SyntaxError {
 	constructor(message, expected, found, location) {
 		super(message);
@@ -313,13 +323,13 @@ function peg$parse(input, options) {
 	const peg$e75 = peg$classExpectation(["\r", "\n"], true, false, false);
 	const peg$e76 = peg$otherExpectation("comment");
 	function peg$f0(statemachine) {
-		statemachine.states = parserHelpers.extractUndeclaredStates(statemachine);
-		return parserHelpers.classifyForkJoins(statemachine);
+		statemachine.states = extractUndeclaredStates(statemachine);
+		return classifyForkJoins(statemachine);
 	}
 	function peg$f1(states, transitions) {
 		let lStateMachine = {};
-		parserHelpers.setIf(lStateMachine, "states", states);
-		parserHelpers.setIfNotEmpty(lStateMachine, "transitions", transitions);
+		setIf(lStateMachine, "states", states);
+		setIfNotEmpty(lStateMachine, "transitions", transitions);
 		return lStateMachine;
 	}
 	function peg$f2(state) {
@@ -329,10 +339,7 @@ function peg$parse(input, options) {
 		return state;
 	}
 	function peg$f4(states) {
-		return parserHelpers.uniq(
-			states[0].concat(states[1]),
-			parserHelpers.stateEqual,
-		);
+		return uniq(states[0].concat(states[1]), stateEqual);
 	}
 	function peg$f5(notes, id, attrs) {
 		return attrs;
@@ -344,29 +351,21 @@ function peg$parse(input, options) {
 		return sm;
 	}
 	function peg$f8(notes, id, extended_state_attributes, actions, statemachine) {
-		let lState = parserHelpers.initState(id);
-		(extended_state_attributes || []).forEach((pExtendedAttribute) =>
-			parserHelpers.setIf(
-				lState,
-				pExtendedAttribute.name,
-				pExtendedAttribute.value,
-			),
-		);
-		parserHelpers.setIf(
+		let lState = initState(id);
+		for (const lExtendedAttribute of extended_state_attributes || []) {
+			setIf(lState, lExtendedAttribute.name, lExtendedAttribute.value);
+		}
+		setIf(
 			lState,
 			"typeExplicitlySet",
 			(extended_state_attributes || []).some(
 				(pExtendedAttribute) => pExtendedAttribute.typeExplicitlySet,
 			),
 		);
-		parserHelpers.setIf(lState, "statemachine", statemachine);
-		parserHelpers.setIfNotEmpty(lState, "note", notes);
+		setIf(lState, "statemachine", statemachine);
+		setIfNotEmpty(lState, "note", notes);
 		if (actions) {
-			parserHelpers.setIfNotEmpty(
-				lState,
-				"actions",
-				parserHelpers.extractActions(actions),
-			);
+			setIfNotEmpty(lState, "actions", extractActions(actions));
 		}
 		return lState;
 	}
@@ -403,19 +402,12 @@ function peg$parse(input, options) {
 	function peg$f19(notes, trans, extended_attributes, label) {
 		if (label) {
 			trans.label = label;
-			trans = Object.assign(
-				trans,
-				parserHelpers.parseTransitionExpression(label),
-			);
+			trans = Object.assign(trans, parseTransitionExpression(label));
 		}
-		(extended_attributes || []).forEach((pExtendedAttribute) =>
-			parserHelpers.setIf(
-				trans,
-				pExtendedAttribute.name,
-				pExtendedAttribute.value,
-			),
-		);
-		parserHelpers.setIfNotEmpty(trans, "note", notes);
+		for (const lExtendedAttribute of extended_attributes || []) {
+			setIf(trans, lExtendedAttribute.name, lExtendedAttribute.value);
+		}
+		setIfNotEmpty(trans, "note", notes);
 		trans.id = options.counter.next();
 		return trans;
 	}

package/dist/render/dot/attributebuilder.mjs

@@ -37,11 +37,20 @@ function toNameValueString(pAttribute) {
 	return `${pAttribute.name}=${pAttribute.value}`;
 }
 export function buildGraphAttributes(pEngine, pDirection, pDotGraphAttributes) {
-	return GENERIC_GRAPH_ATTRIBUTES.concat(GRAPH_ATTRIBUTES[pEngine] || [])
-		.concat(DIRECTION_ATTRIBUTES[pDirection] || [])
-		.concat(pDotGraphAttributes || [])
-		.map(toNameValueString)
-		.join(" ");
+	const lParts = [];
+	for (const lAttribute of GENERIC_GRAPH_ATTRIBUTES) {
+		lParts.push(lAttribute);
+	}
+	for (const lAttribute of GRAPH_ATTRIBUTES[pEngine] || []) {
+		lParts.push(lAttribute);
+	}
+	for (const lAttribute of DIRECTION_ATTRIBUTES[pDirection] || []) {
+		lParts.push(lAttribute);
+	}
+	for (const lAttribute of pDotGraphAttributes || []) {
+		lParts.push(lAttribute);
+	}
+	return lParts.map(toNameValueString).join(" ");
 }
 export function buildNodeAttributes(pDotNodeAttributes) {
 	return NODE_ATTRIBUTES.concat(pDotNodeAttributes || [])
@@ -53,8 +62,3 @@ export function buildEdgeAttributes(pDotEdgeAttributes) {
 		.map(toNameValueString)
 		.join(" ");
 }
-export default {
-	buildGraphAttributes,
-	buildNodeAttributes,
-	buildEdgeAttributes,
-};

package/dist/render/dot/index.mjs

@@ -180,9 +180,9 @@ function state(pState, pIndent, pOptions, pModel, pRenderedTransitions) {
 		pState.name,
 		pRenderedTransitions,
 	);
-	lCandidateTransitions.forEach((pTransition) => {
-		pRenderedTransitions.add(pTransition.id);
-	});
+	for (const lTransition of lCandidateTransitions) {
+		pRenderedTransitions.add(lTransition.id);
+	}
 	const lTransitions = transitions(
 		lCandidateTransitions,
 		pIndent,

package/dist/render/index-node.mjs

@@ -1,26 +1,23 @@
-import smcatRendererAsImported from "./smcat.mjs";
-import renderDot from "./dot/index.mjs";
-import vector from "./vector/vector-native-dot-with-fallback.mjs";
-import oldVector from "./vector/vector-with-wasm.mjs";
-import scjson from "./scjson/index.mjs";
-import scxml from "./scxml/index.mjs";
-const smcat = smcatRendererAsImported;
-export default function getRenderFunction(pOutputType) {
-	const lOutputType2RenderFunctionMap = new Map([
-		["smcat", smcat],
-		["dot", renderDot],
-		["svg", vector],
-		["dot", renderDot],
-		["eps", vector],
-		["ps", vector],
-		["ps2", vector],
-		["oldsvg", oldVector],
-		["oldps2", oldVector],
-		["oldeps", oldVector],
-		["pdf", vector],
-		["png", vector],
-		["scjson", scjson],
-		["scxml", scxml],
-	]);
-	return lOutputType2RenderFunctionMap.get(pOutputType) ?? ((pX) => pX);
+const OUTPUT_TYPE2RENDER_MODULE = new Map([
+	["smcat", "./smcat.mjs"],
+	["dot", "./dot/index.mjs"],
+	["svg", "./vector/vector-native-dot-with-fallback.mjs"],
+	["eps", "./vector/vector-native-dot-with-fallback.mjs"],
+	["ps", "./vector/vector-native-dot-with-fallback.mjs"],
+	["ps2", "./vector/vector-native-dot-with-fallback.mjs"],
+	["oldsvg", "./vector/vector-with-wasm.mjs"],
+	["oldps2", "./vector/vector-with-wasm.mjs"],
+	["oldeps", "./vector/vector-with-wasm.mjs"],
+	["pdf", "./vector/vector-native-dot-with-fallback.mjs"],
+	["png", "./vector/vector-native-dot-with-fallback.mjs"],
+	["scjson", "./scjson/index.mjs"],
+	["scxml", "./scxml/index.mjs"],
+]);
+export default async function getRenderFunction(pOutputType) {
+	const lModulePath = OUTPUT_TYPE2RENDER_MODULE.get(pOutputType);
+	if (lModulePath) {
+		const lImportedModule = await import(lModulePath);
+		return lImportedModule.default;
+	}
+	return (pX) => pX;
 }

package/dist/render/index.mjs

@@ -1,17 +1,42 @@
-import smcatRendererAsImported from "./smcat.mjs";
-import renderDot from "./dot/index.mjs";
-import svg from "./vector/vector-with-wasm.mjs";
-import scjson from "./scjson/index.mjs";
-import scxml from "./scxml/index.mjs";
-const smcat = smcatRendererAsImported;
-export default function getRenderFunction(pOutputType) {
-	const lOutputType2RenderFunctionMap = new Map([
-		["smcat", smcat],
-		["dot", renderDot],
-		["svg", svg],
-		["oldsvg", svg],
-		["scjson", scjson],
-		["scxml", scxml],
-	]);
-	return lOutputType2RenderFunctionMap.get(pOutputType) ?? ((pX) => pX);
+let gSmCatModule = null;
+let gDotModule = null;
+let gSVGModule = null;
+let gSCJSONModule = null;
+let gSCXMLModule = null;
+export default async function getRenderFunction(pOutputType) {
+	switch (pOutputType) {
+		case "smcat": {
+			if (!gSmCatModule) {
+				gSmCatModule = await import("./smcat.mjs");
+			}
+			return gSmCatModule.default;
+		}
+		case "dot": {
+			if (!gDotModule) {
+				gDotModule = await import("./dot/index.mjs");
+			}
+			return gDotModule.default;
+		}
+		case "svg":
+		case "oldsvg": {
+			if (!gSVGModule) {
+				gSVGModule = await import("./vector/vector-with-wasm.mjs");
+			}
+			return gSVGModule.default;
+		}
+		case "scjson": {
+			if (!gSCJSONModule) {
+				gSCJSONModule = await import("./scjson/index.mjs");
+			}
+			return gSCJSONModule.default;
+		}
+		case "scxml": {
+			if (!gSCXMLModule) {
+				gSCXMLModule = await import("./scxml/index.mjs");
+			}
+			return gSCXMLModule.default;
+		}
+		default:
+			return (pX) => pX;
+	}
 }

package/dist/render/vector/dot-to-vector-native.mjs

@@ -3,7 +3,7 @@ const DEFAULT_OPTIONS = {
 	exec: "dot",
 	format: "svg",
 };
-function convert(pDot, pOptions) {
+export function convert(pDot, pOptions) {
 	const lOptions = {
 		...DEFAULT_OPTIONS,
 		...pOptions,
@@ -23,7 +23,7 @@ function convert(pDot, pOptions) {
 		throw new Error(`Unexpected error occurred. Exit code ${status}`);
 	}
 }
-function isAvailable(pOptions) {
+export function isAvailable(pOptions) {
 	const lOptions = {
 		...DEFAULT_OPTIONS,
 		...pOptions,
@@ -33,7 +33,3 @@ function isAvailable(pOptions) {
 		status === 0 && stderr.toString("utf8").startsWith("dot - graphviz version")
 	);
 }
-export default {
-	convert,
-	isAvailable,
-};

package/dist/render/vector/vector-native-dot-with-fallback.mjs

@@ -1,17 +1,17 @@
 import { Graphviz } from "@hpcc-js/wasm-graphviz";
-import options from "../../options.mjs";
+import { getOptionValue } from "../../options.mjs";
 import ast2dot from "../dot/index.mjs";
-import dotToVectorNative from "./dot-to-vector-native.mjs";
+import { isAvailable, convert } from "./dot-to-vector-native.mjs";
 const VIZ_JS_UNSUPPORTED_OUTPUT_FORMATS = ["pdf", "png"];
 const gGraphViz = await Graphviz.load();
 const renderVector = (pStateMachine, pOptions) => {
 	const lDotProgram = ast2dot(pStateMachine, pOptions);
 	const lDotOptions = {
-		engine: options.getOptionValue(pOptions, "engine"),
-		format: options.getOptionValue(pOptions, "outputType"),
+		engine: getOptionValue(pOptions, "engine"),
+		format: getOptionValue(pOptions, "outputType"),
 	};
-	if (dotToVectorNative.isAvailable(pOptions)) {
-		return dotToVectorNative.convert(lDotProgram, lDotOptions);
+	if (isAvailable(pOptions)) {
+		return convert(lDotProgram, lDotOptions);
 	} else {
 		if (VIZ_JS_UNSUPPORTED_OUTPUT_FORMATS.includes(lDotOptions.format)) {
 			throw new Error(

package/dist/render/vector/vector-with-wasm.mjs

@@ -1,5 +1,5 @@
 import { Graphviz } from "@hpcc-js/wasm-graphviz";
-import options from "../../options.mjs";
+import { getOptionValue } from "../../options.mjs";
 import ast2dot from "../dot/index.mjs";
 const OUTPUT_TYPE2FORMAT = {
 	oldsvg: "svg",
@@ -8,12 +8,10 @@ const OUTPUT_TYPE2FORMAT = {
 };
 const gGraphViz = await Graphviz.load();
 function getFormat(pOptions) {
-	return (
-		OUTPUT_TYPE2FORMAT[options.getOptionValue(pOptions, "outputType")] || "svg"
-	);
+	return OUTPUT_TYPE2FORMAT[getOptionValue(pOptions, "outputType")] || "svg";
 }
 function getEngine(pOptions) {
-	return options.getOptionValue(pOptions, "engine");
+	return getOptionValue(pOptions, "engine");
 }
 const renderVectorWithWasm = (pStateMachine, pOptions) =>
 	gGraphViz.layout(

package/dist/state-machine-model.mjs

@@ -1,19 +1,17 @@
 function flattenStatesToMap(pStates, pMap, pParent = "") {
-	pStates
-		.filter((pState) => Boolean(pState.statemachine))
-		.forEach((pState) => {
-			if (Object.hasOwn(pState.statemachine, "states")) {
-				flattenStatesToMap(pState.statemachine.states, pMap, pState.name);
-			}
-		});
-	pStates.forEach((pState) =>
-		pMap.set(pState.name, {
-			name: pState.name,
-			type: pState.type,
-			statemachine: Boolean(pState.statemachine),
+	for (const lState of pStates) {
+		if (lState?.statemachine?.states) {
+			flattenStatesToMap(lState.statemachine.states, pMap, lState.name);
+		}
+	}
+	for (const lState of pStates) {
+		pMap.set(lState.name, {
+			name: lState.name,
+			type: lState.type,
+			statemachine: Boolean(lState.statemachine),
 			parent: pParent,
-		}),
-	);
+		});
+	}
 }
 function flattenTransitions(pStateMachine) {
 	let lTransitions = [];
@@ -21,13 +19,13 @@ function flattenTransitions(pStateMachine) {
 		lTransitions = structuredClone(pStateMachine.transitions);
 	}
 	if (Object.hasOwn(pStateMachine, "states")) {
-		pStateMachine.states
-			.filter((pState) => Boolean(pState.statemachine))
-			.forEach((pState) => {
+		for (const lState of pStateMachine.states) {
+			if (lState.statemachine) {
 				lTransitions = lTransitions.concat(
-					flattenTransitions(pState.statemachine),
+					flattenTransitions(lState.statemachine),
 				);
-			});
+			}
+		}
 	}
 	return lTransitions;
 }

package/dist/transform/desugar.mjs

@@ -1,6 +1,6 @@
 import StateMachineModel from "../state-machine-model.mjs";
 import { Counter } from "../counter.mjs";
-import utl from "./utl.mjs";
+import { formatLabel } from "./utl.mjs";
 function fuseTransitionAttribute(pIncomingThing, pOutgoingThing, pJoinChar) {
 	return pIncomingThing
 		? `${pIncomingThing}${pJoinChar}${pOutgoingThing}`
@@ -26,7 +26,7 @@ function fuseIncomingToOutgoing(
 		);
 	}
 	if (lReturnValue.event || lReturnValue.cond || lReturnValue.action) {
-		lReturnValue.label = utl.formatLabel(
+		lReturnValue.label = formatLabel(
 			lReturnValue.event,
 			lReturnValue.cond,
 			lReturnValue.action,
@@ -40,20 +40,24 @@ function fuseTransitions(
 	pOutgoingTransitionMap,
 	pCounter,
 ) {
-	return pTransitions.reduce((pAll, pTransition) => {
-		pPseudoStateNames.forEach((pStateName, pIndex) => {
-			if (pStateName === pTransition.to && pOutgoingTransitionMap[pStateName]) {
-				pAll = pAll.concat(
-					pOutgoingTransitionMap[pStateName].map((pOutgoingTransition) =>
-						fuseIncomingToOutgoing(pTransition, pOutgoingTransition, pCounter),
-					),
-				);
-			} else {
-				pAll = pIndex === 0 ? pAll.concat(pTransition) : pAll;
+	const lResult = [];
+	for (const lTransition of pTransitions) {
+		let lAdded = false;
+		for (const lStateName of pPseudoStateNames) {
+			if (lStateName === lTransition.to && pOutgoingTransitionMap[lStateName]) {
+				for (const lOutgoing of pOutgoingTransitionMap[lStateName]) {
+					lResult.push(
+						fuseIncomingToOutgoing(lTransition, lOutgoing, pCounter),
+					);
+				}
+				lAdded = true;
 			}
-		});
-		return pAll;
-	}, []);
+		}
+		if (!lAdded) {
+			lResult.push(lTransition);
+		}
+	}
+	return lResult;
 }
 function deSugarPseudoStates(
 	pMachine,

package/dist/transform/utl.mjs

@@ -1,4 +1,4 @@
-function formatLabel(pEvent, pCond, pActions) {
+export function formatLabel(pEvent, pCond, pActions) {
 	let lReturnValue = "";
 	if (pEvent) {
 		lReturnValue += pEvent;
@@ -11,6 +11,3 @@ function formatLabel(pEvent, pCond, pActions) {
 	}
 	return lReturnValue.trim();
 }
-export default {
-	formatLabel,
-};

package/dist/version.mjs

@@ -1 +1 @@
-export const version = "13.0.2";
+export const version = "14.0.0";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "state-machine-cat",
-	"version": "13.0.2",
+	"version": "14.0.0",
 	"description": "write beautiful state charts",
 	"type": "module",
 	"main": "./dist/index.mjs",

package/types/state-machine-cat.d.mts

@@ -286,7 +286,7 @@ export type RenderFunctionType =
  * @param pScript     The script to translate
  * @param pOptions    options influencing parsing & rendering.
  *                    See below for the complete list.
- * @return            the string with the rendered content if
+ * @return            a promise to the string with the rendered content if
  *                    no error was found
  * @throws {Error}    If an error occurred and no callback
  *                    function was passed: the error
@@ -297,4 +297,4 @@ export type RenderFunctionType =
 export function render(
 	pScript: IStateMachine | string,
 	pOptions: IRenderOptions,
-): string;
+): Promise<string>;