jssm 5.79.18 → 5.81.0

package/dist/es6/jssm.js

@@ -1,6 +1,7 @@
 // whargarbl lots of these return arrays could/should be sets
 import { reduce as reduce_to_639 } from 'reduce-to-639-1';
 import { circular_buffer } from 'circular_buffer_js';
+import { base_state_style, base_start_state_style, base_end_state_style, base_terminal_state_style, base_active_state_style } from './jssm_base_stylesheet';
 import { seq, unique, find_repeated, weighted_rand_select, weighted_sample_select, histograph, weighted_histo_key, array_box_if_string, name_bind_prop_and_state, hook_name, named_hook_name } from './jssm_util';
 import * as constants from './jssm_constants';
 const { shapes, gviz_shapes, named_colors } = constants;
@@ -271,7 +272,7 @@ function makeTransition(this_se, from, to, isRight, _wasList, _wasIndex) {
  *  ```typescript
  *  import { sm } from 'jssm';
  *
- *  const switch = sm`on <=> off;`;
+ *  const lswitch = sm`on <=> off;`;
  *  ```
  *
  *  Method {@link from}:
@@ -379,7 +380,9 @@ function compile_rule_handler(rule) {
         'graph_layout', 'start_states', 'end_states', 'machine_name', 'machine_version',
         'machine_comment', 'machine_author', 'machine_contributor', 'machine_definition',
         'machine_reference', 'machine_license', 'fsl_version', 'state_config', 'theme',
-        'flow', 'dot_preamble'
+        'flow', 'dot_preamble', 'default_state_config', 'default_start_state_config',
+        'default_end_state_config', 'default_hooked_state_config',
+        'default_active_state_config', 'default_terminal_state_config'
     ];
     if (tautologies.includes(rule.key)) {
         return { agg_as: rule.key, val: rule.value };
@@ -421,7 +424,7 @@ function compile_rule_handler(rule) {
  *  ```typescript
  *  import { sm } from 'jssm';
  *
- *  const switch = sm`on <=> off;`;
+ *  const lswitch = sm`on <=> off;`;
  *  ```
  *
  *  Method {@link from}:
@@ -462,7 +465,13 @@ function compile(tree) {
         arrange_declaration: [],
         arrange_start_declaration: [],
         arrange_end_declaration: [],
-        machine_version: []
+        machine_version: [],
+        default_state_config: [],
+        default_active_state_config: [],
+        default_hooked_state_config: [],
+        default_terminal_state_config: [],
+        default_start_state_config: [],
+        default_end_state_config: [],
     };
     tree.map((tr) => {
         const rule = compile_rule_handler(tr), agg_as = rule.agg_as, val = rule.val; // TODO FIXME no any
@@ -475,8 +484,9 @@ function compile(tree) {
     const assembled_transitions = [].concat(...results['transition']);
     const result_cfg = {
         start_states: results.start_states.length ? results.start_states : [assembled_transitions[0].from],
+        end_states: results.end_states,
         transitions: assembled_transitions,
-        state_property: []
+        state_property: [],
     };
     const oneOnlyKeys = [
         'graph_layout', 'machine_name', 'machine_version', 'machine_comment',
@@ -495,7 +505,10 @@ function compile(tree) {
     });
     ['arrange_declaration', 'arrange_start_declaration', 'arrange_end_declaration',
         'machine_author', 'machine_contributor', 'machine_reference',
-        'state_declaration', 'property_definition'].map((multiKey) => {
+        'state_declaration', 'property_definition', 'default_state_config',
+        'default_start_state_config', 'default_end_state_config',
+        'default_hooked_state_config', 'default_terminal_state_config',
+        'default_active_state_config'].map((multiKey) => {
         if (results[multiKey].length) {
             result_cfg[multiKey] = results[multiKey];
         }
@@ -552,8 +565,8 @@ function transfer_state_properties(state_decl) {
             case 'corners':
                 state_decl.corners = d.value;
                 break;
-            case 'linestyle':
-                state_decl.linestyle = d.value;
+            case 'line-style':
+                state_decl.lineStyle = d.value;
                 break;
             case 'text-color':
                 state_decl.textColor = d.value;
@@ -561,6 +574,9 @@ function transfer_state_properties(state_decl) {
             case 'background-color':
                 state_decl.backgroundColor = d.value;
                 break;
+            case 'state-label':
+                state_decl.stateLabel = d.value;
+                break;
             case 'border-color':
                 state_decl.borderColor = d.value;
                 break;
@@ -572,10 +588,80 @@ function transfer_state_properties(state_decl) {
     });
     return state_decl;
 }
+function state_style_condense(jssk) {
+    const state_style = {};
+    if (Array.isArray(jssk)) {
+        jssk.forEach((key, i) => {
+            if (typeof key !== 'object') {
+                throw new JssmError(this, `invalid state item ${i} in state_style_condense list: ${JSON.stringify(key)}`);
+            }
+            switch (key.key) {
+                case 'shape':
+                    if (state_style.shape !== undefined) {
+                        throw new JssmError(this, `cannot redefine 'shape' in state_style_condense, already defined`);
+                    }
+                    state_style.shape = key.value;
+                    break;
+                case 'color':
+                    if (state_style.color !== undefined) {
+                        throw new JssmError(this, `cannot redefine 'color' in state_style_condense, already defined`);
+                    }
+                    state_style.color = key.value;
+                    break;
+                case 'text-color':
+                    if (state_style.textColor !== undefined) {
+                        throw new JssmError(this, `cannot redefine 'text-color' in state_style_condense, already defined`);
+                    }
+                    state_style.textColor = key.value;
+                    break;
+                case 'corners':
+                    if (state_style.corners !== undefined) {
+                        throw new JssmError(this, `cannot redefine 'corners' in state_style_condense, already defined`);
+                    }
+                    state_style.corners = key.value;
+                    break;
+                case 'line-style':
+                    if (state_style.lineStyle !== undefined) {
+                        throw new JssmError(this, `cannot redefine 'line-style' in state_style_condense, already defined`);
+                    }
+                    state_style.lineStyle = key.value;
+                    break;
+                case 'background-color':
+                    if (state_style.backgroundColor !== undefined) {
+                        throw new JssmError(this, `cannot redefine 'background-color' in state_style_condense, already defined`);
+                    }
+                    state_style.backgroundColor = key.value;
+                    break;
+                case 'state-label':
+                    if (state_style.stateLabel !== undefined) {
+                        throw new JssmError(this, `cannot redefine 'state-label' in state_style_condense, already defined`);
+                    }
+                    state_style.stateLabel = key.value;
+                    break;
+                case 'border-color':
+                    if (state_style.borderColor !== undefined) {
+                        throw new JssmError(this, `cannot redefine 'border-color' in state_style_condense, already defined`);
+                    }
+                    state_style.borderColor = key.value;
+                    break;
+                default:
+                    // TODO do that <never> trick to assert this list is complete
+                    throw new JssmError(this, `unknown state style key in condense: ${key.key}`);
+            }
+        });
+    }
+    else if (jssk === undefined) {
+        // do nothing, undefined is legal and means we should return the empty container above
+    }
+    else {
+        throw new JssmError(this, 'state_style_condense received a non-array');
+    }
+    return state_style;
+}
 // TODO add a lotta docblock here
 class Machine {
     // whargarbl this badly needs to be broken up, monolith master
-    constructor({ start_states, complete = [], transitions, machine_author, machine_comment, machine_contributor, machine_definition, machine_language, machine_license, machine_name, machine_version, state_declaration, property_definition, state_property, fsl_version, dot_preamble = undefined, arrange_declaration = [], arrange_start_declaration = [], arrange_end_declaration = [], theme = 'default', flow = 'down', graph_layout = 'dot', instance_name, history, data }) {
+    constructor({ start_states, end_states = [], complete = [], transitions, machine_author, machine_comment, machine_contributor, machine_definition, machine_language, machine_license, machine_name, machine_version, state_declaration, property_definition, state_property, fsl_version, dot_preamble = undefined, arrange_declaration = [], arrange_start_declaration = [], arrange_end_declaration = [], theme = 'default', flow = 'down', graph_layout = 'dot', instance_name, history, data, default_state_config, default_active_state_config, default_hooked_state_config, default_terminal_state_config, default_start_state_config, default_end_state_config }) {
         this._instance_name = instance_name;
         this._state = start_states[0];
         this._states = new Map();
@@ -586,6 +672,8 @@ class Machine {
         this._actions = new Map();
         this._reverse_actions = new Map();
         this._reverse_action_targets = new Map(); // todo
+        this._start_states = new Set(start_states);
+        this._end_states = new Set(end_states); // todo consider what to do about incorporating complete too
         this._machine_author = array_box_if_string(machine_author);
         this._machine_comment = machine_comment;
         this._machine_contributor = array_box_if_string(machine_contributor);
@@ -644,8 +732,16 @@ class Machine {
         this._default_properties = new Map();
         this._state_properties = new Map();
         this._required_properties = new Set();
+        this._state_style = state_style_condense(default_state_config);
+        this._active_state_style = state_style_condense(default_active_state_config);
+        this._hooked_state_style = state_style_condense(default_hooked_state_config);
+        this._terminal_state_style = state_style_condense(default_terminal_state_config);
+        this._start_state_style = state_style_condense(default_start_state_config);
+        this._end_state_style = state_style_condense(default_end_state_config);
         this._history_length = history || 0;
         this._history = new circular_buffer(this._history_length);
+        this._state_labels = new Map();
+        // consolidate the state declarations
         if (state_declaration) {
             state_declaration.map((state_decl) => {
                 if (this._state_declarations.has(state_decl.state)) { // no repeats
@@ -654,6 +750,17 @@ class Machine {
                 this._state_declarations.set(state_decl.state, transfer_state_properties(state_decl));
             });
         }
+        // walk the decls for labels; aggregate them when found
+        [...this._state_declarations].map(sd => {
+            const [key, decl] = sd, labelled = decl.declarations.filter(d => d.key === 'state-label');
+            if (labelled.length > 1) {
+                throw new JssmError(this, `state ${key} may only have one state-label; has ${labelled.length}`);
+            }
+            if (labelled.length === 1) {
+                this._state_labels.set(key, labelled[0].value);
+            }
+        });
+        // walk the transitions
         transitions.map((tr) => {
             if (tr.from === undefined) {
                 throw new JssmError(this, `transition must define 'from': ${JSON.stringify(tr)}`);
@@ -805,11 +912,11 @@ class Machine {
      *  ```typescript
      *  import * as jssm from 'jssm';
      *
-     *  const switch = jssm.from('on <=> off;');
-     *  console.log( switch.state() );             // 'on'
+     *  const lswitch = jssm.from('on <=> off;');
+     *  console.log( lswitch.state() );             // 'on'
      *
-     *  switch.transition('off');
-     *  console.log( switch.state() );             // 'off'
+     *  lswitch.transition('off');
+     *  console.log( lswitch.state() );             // 'off'
      *  ```
      *
      *  @typeparam mDT The type of the machine data member; usually omitted
@@ -818,13 +925,23 @@ class Machine {
     state() {
         return this._state;
     }
-    /* whargarbl todo major
-       when we reimplement this, reintroduce this change to the is_final call
-  
-      is_changing(): boolean {
-        return true; // todo whargarbl
-      }
-    */
+    /*********
+     *
+     *  Get the label for a given state, if any; return `undefined` otherwise.
+     *
+     *  ```typescript
+     *  import * as jssm from 'jssm';
+     *
+     *  const lswitch = jssm.from('a -> b; state a: { label: "Foo!"; };');
+     *  console.log( lswitch.label_for('a') );              // 'Foo!'
+     *  ```
+     *
+     *  @typeparam mDT The type of the machine data member; usually omitted
+     *
+     */
+    label_for(state) {
+        return this._state_labels.get(state);
+    }
     /*********
      *
      *  Get the current data of a machine.
@@ -832,8 +949,8 @@ class Machine {
      *  ```typescript
      *  import * as jssm from 'jssm';
      *
-     *  const switch = jssm.from('on <=> off;', {data: 1});
-     *  console.log( switch.data() );              // 1
+     *  const lswitch = jssm.from('on <=> off;', {data: 1});
+     *  console.log( lswitch.data() );              // 1
      *  ```
      *
      *  @typeparam mDT The type of the machine data member; usually omitted
@@ -842,13 +959,6 @@ class Machine {
     data() {
         return this._data;
     }
-    /* whargarbl todo major
-       when we reimplement this, reintroduce this change to the is_final call
-  
-      is_changing(): boolean {
-        return true; // todo whargarbl
-      }
-    */
     // NEEDS_DOCS
     /*********
      *
@@ -1008,6 +1118,60 @@ class Machine {
     known_props() {
         return [...this._property_keys];
     }
+    /********
+     *
+     *  Check whether a given state is a valid start state (either because it was
+     *  explicitly named as such, or because it was the first mentioned state.)
+     *
+     *  ```typescript
+     *  import { sm, is_start_state } from 'jssm';
+     *
+     *  const example = sm`a -> b;`;
+     *
+     *  console.log( final_test.is_start_state('a') );   // true
+     *  console.log( final_test.is_start_state('b') );   // false
+     *
+     *  const example = sm`start_states: [a b]; a -> b;`;
+     *
+     *  console.log( final_test.is_start_state('a') );   // true
+     *  console.log( final_test.is_start_state('b') );   // true
+     *  ```
+     *
+     *  @typeparam mDT The type of the machine data member; usually omitted
+     *
+     *  @param whichState The name of the state to check
+     *
+     */
+    is_start_state(whichState) {
+        return this._start_states.has(whichState);
+    }
+    /********
+     *
+     *  Check whether a given state is a valid start state (either because it was
+     *  explicitly named as such, or because it was the first mentioned state.)
+     *
+     *  ```typescript
+     *  import { sm, is_end_state } from 'jssm';
+     *
+     *  const example = sm`a -> b;`;
+     *
+     *  console.log( final_test.is_start_state('a') );   // false
+     *  console.log( final_test.is_start_state('b') );   // true
+     *
+     *  const example = sm`end_states: [a b]; a -> b;`;
+     *
+     *  console.log( final_test.is_start_state('a') );   // true
+     *  console.log( final_test.is_start_state('b') );   // true
+     *  ```
+     *
+     *  @typeparam mDT The type of the machine data member; usually omitted
+     *
+     *  @param whichState The name of the state to check
+     *
+     */
+    is_end_state(whichState) {
+        return this._end_states.has(whichState);
+    }
     /********
      *
      *  Check whether a given state is final (either has no exits or is marked
@@ -1028,7 +1192,7 @@ class Machine {
      *
      */
     state_is_final(whichState) {
-        return ((this.state_is_terminal(whichState)) && (this.state_is_complete(whichState)));
+        return ((this.state_is_terminal(whichState)) || (this.state_is_complete(whichState)));
     }
     /********
      *
@@ -1036,7 +1200,7 @@ class Machine {
      *  `complete`.)
      *
      *  ```typescript
-     *  import { sm, state_is_final } from 'jssm';
+     *  import { sm, is_final } from 'jssm';
      *
      *  const final_test = sm`first -> second;`;
      *
@@ -1134,8 +1298,8 @@ class Machine {
      *  ```typescript
      *  import * as jssm from 'jssm';
      *
-     *  const switch = jssm.from('on <=> off;');
-     *  console.log( switch.states() );             // ['on', 'off']
+     *  const lswitch = jssm.from('on <=> off;');
+     *  console.log( lswitch.states() );             // ['on', 'off']
      *  ```
      *
      *  @typeparam mDT The type of the machine data member; usually omitted
@@ -1160,10 +1324,10 @@ class Machine {
      *  ```typescript
      *  import * as jssm from 'jssm';
      *
-     *  const switch = jssm.from('on <=> off;');
+     *  const lswitch = jssm.from('on <=> off;');
      *
-     *  console.log( switch.has_state('off') );     // true
-     *  console.log( switch.has_state('dance') );   // false
+     *  console.log( lswitch.has_state('off') );     // true
+     *  console.log( lswitch.has_state('dance') );   // false
      *  ```
      *
      *  @typeparam mDT The type of the machine data member; usually omitted
@@ -2003,6 +2167,237 @@ class Machine {
     action(actionName, newData) {
         return this.transition_impl(actionName, newData, false, true);
     }
+    /********
+     *
+     *  Get the standard style for a single state.  ***Does not*** include
+     *  composition from an applied theme, or things from the underlying base
+     *  stylesheet; only the modifications applied by this machine.
+     *
+     *  ```typescript
+     *  const light = sm`a -> b;`;
+     *  console.log(light.standard_state_style);
+     *  // {}
+     *
+     *  const light = sm`a -> b; state: { shape: circle; };`;
+     *  console.log(light.standard_state_style);
+     *  // { shape: 'circle' }
+     *  ```
+     *
+     *  @typeparam mDT The type of the machine data member; usually omitted
+     *
+     */
+    get standard_state_style() {
+        return this._state_style;
+    }
+    /********
+     *
+     *  Get the hooked state style.  ***Does not*** include
+     *  composition from an applied theme, or things from the underlying base
+     *  stylesheet; only the modifications applied by this machine.
+     *
+     *  The hooked style is only applied to nodes which have a named hook in the
+     *  graph.  Open hooks set through the external API aren't graphed, because
+     *  that would be literally every node.
+     *
+     *  ```typescript
+     *  const light = sm`a -> b;`;
+     *  console.log(light.hooked_state_style);
+     *  // {}
+     *
+     *  const light = sm`a -> b; hooked_state: { shape: circle; };`;
+     *  console.log(light.hooked_state_style);
+     *  // { shape: 'circle' }
+     *  ```
+     *
+     *  @typeparam mDT The type of the machine data member; usually omitted
+     *
+     */
+    get hooked_state_style() {
+        return this._hooked_state_style;
+    }
+    /********
+     *
+     *  Get the start state style.  ***Does not*** include composition from an
+     *  applied theme, or things from the underlying base stylesheet; only the
+     *  modifications applied by this machine.
+     *
+     *  Start states are defined by the directive `start_states`, or in absentia,
+     *  are the first mentioned state.
+     *
+     *  ```typescript
+     *  const light = sm`a -> b;`;
+     *  console.log(light.start_state_style);
+     *  // {}
+     *
+     *  const light = sm`a -> b; start_state: { shape: circle; };`;
+     *  console.log(light.start_state_style);
+     *  // { shape: 'circle' }
+     *  ```
+     *
+     *  @typeparam mDT The type of the machine data member; usually omitted
+     *
+     */
+    get start_state_style() {
+        return this._start_state_style;
+    }
+    /********
+     *
+     *  Get the end state style.  ***Does not*** include
+     *  composition from an applied theme, or things from the underlying base
+     *  stylesheet; only the modifications applied by this machine.
+     *
+     *  End states are defined in the directive `end_states`, and are distinct
+     *  from terminal states.  End states are voluntary successful endpoints for a
+     *  process.  Terminal states are states that cannot be exited.  By example,
+     *  most error states are terminal states, but not end states.  Also, since
+     *  some end states can be exited and are determined by hooks, such as
+     *  recursive or iterative nodes, there is such a thing as an end state that
+     *  is not a terminal state.
+     *
+     *  ```typescript
+     *  const light = sm`a -> b;`;
+     *  console.log(light.standard_state_style);
+     *  // {}
+     *
+     *  const light = sm`a -> b; end_state: { shape: circle; };`;
+     *  console.log(light.standard_state_style);
+     *  // { shape: 'circle' }
+     *  ```
+     *
+     *  @typeparam mDT The type of the machine data member; usually omitted
+     *
+     */
+    get end_state_style() {
+        return this._end_state_style;
+    }
+    /********
+     *
+     *  Get the terminal state style.  ***Does not*** include
+     *  composition from an applied theme, or things from the underlying base
+     *  stylesheet; only the modifications applied by this machine.
+     *
+     *  Terminal state styles are automatically determined by the machine.  Any
+     *  state without a valid exit transition is terminal.
+     *
+     *  ```typescript
+     *  const light = sm`a -> b;`;
+     *  console.log(light.terminal_state_style);
+     *  // {}
+     *
+     *  const light = sm`a -> b; terminal_state: { shape: circle; };`;
+     *  console.log(light.terminal_state_style);
+     *  // { shape: 'circle' }
+     *  ```
+     *
+     *  @typeparam mDT The type of the machine data member; usually omitted
+     *
+     */
+    get terminal_state_style() {
+        return this._terminal_state_style;
+    }
+    /********
+     *
+     *  Get the style for the active state.  ***Does not*** include
+     *  composition from an applied theme, or things from the underlying base
+     *  stylesheet; only the modifications applied by this machine.
+     *
+     *  ```typescript
+     *  const light = sm`a -> b;`;
+     *  console.log(light.active_state_style);
+     *  // {}
+     *
+     *  const light = sm`a -> b; active_state: { shape: circle; };`;
+     *  console.log(light.active_state_style);
+     *  // { shape: 'circle' }
+     *  ```
+     *
+     *  @typeparam mDT The type of the machine data member; usually omitted
+     *
+     */
+    get active_state_style() {
+        return this._active_state_style;
+    }
+    /********
+     *
+     *  Gets the composite style for a specific node by individually imposing the
+     *  style layers on a given object, after determining which layers are
+     *  appropriate.
+     *
+     *  The order of composition is base, then theme, then user content.  Each
+     *  item in the stack will be composited independently.  First, the base state
+     *  style, then the theme state style, then the user state style.
+     *
+     *  After the three state styles, we'll composite the hooked styles; then the
+     *  terminal styles; then the start styles; then the end styles; finally, the
+     *  active styles.  Remember, last wins.
+     *
+     *  The base state style must exist.  All other styles are optional.
+     *
+     *  @typeparam mDT The type of the machine data member; usually omitted
+     *
+     */
+    style_for(state) {
+        // basic state style
+        const layers = [base_state_style];
+        //  if (theme.state_style) { layers.push(theme.state_style); }
+        if (this._state_style) {
+            layers.push(this._state_style);
+        }
+        /*
+            // hooked state style
+            if (this.has_hooks(state)) {
+              layers.push(base_hooked_state_style);
+        //    if (theme.hooked_state_style) { layers.push(theme.hooked_state_style); }
+              if (this._hooked_state_style) { layers.push(this._hooked_state_style); }
+            }
+        */
+        // terminal state style
+        if (this.state_is_terminal(state)) {
+            layers.push(base_terminal_state_style);
+            //    if (theme.terminal_state_style) { layers.push(theme.terminal_state_style); }
+            if (this._terminal_state_style) {
+                layers.push(this._terminal_state_style);
+            }
+        }
+        // start state style
+        if (this.is_start_state(state)) {
+            layers.push(base_start_state_style);
+            //    if (theme.start_state_style) { layers.push(theme.start_state_style); }
+            if (this._start_state_style) {
+                layers.push(this._start_state_style);
+            }
+        }
+        // end state style
+        if (this.is_end_state(state)) {
+            layers.push(base_end_state_style);
+            //    if (theme.end_state_style) { layers.push(theme.end_state_style); }
+            if (this._end_state_style) {
+                layers.push(this._end_state_style);
+            }
+        }
+        // active state style
+        if (this.state() === state) {
+            layers.push(base_active_state_style);
+            //    if (theme.active_state_style) { layers.push(theme.active_state_style); }
+            if (this._active_state_style) {
+                layers.push(this._active_state_style);
+            }
+        }
+        const individual_style = {}, decl = this._state_declarations.get(state);
+        individual_style.color = decl === null || decl === void 0 ? void 0 : decl.color;
+        individual_style.textColor = decl === null || decl === void 0 ? void 0 : decl.textColor;
+        individual_style.borderColor = decl === null || decl === void 0 ? void 0 : decl.borderColor;
+        individual_style.backgroundColor = decl === null || decl === void 0 ? void 0 : decl.backgroundColor;
+        individual_style.lineStyle = decl === null || decl === void 0 ? void 0 : decl.lineStyle;
+        individual_style.corners = decl === null || decl === void 0 ? void 0 : decl.corners;
+        individual_style.shape = decl === null || decl === void 0 ? void 0 : decl.shape;
+        layers.push(individual_style);
+        return layers.reduce((acc, cur) => {
+            const composite_state = acc;
+            Object.keys(cur).forEach(key => { var _a; return composite_state[key] = (_a = cur[key]) !== null && _a !== void 0 ? _a : composite_state[key]; });
+            return composite_state;
+        }, {});
+    }
     /********
      *
      *  Instruct the machine to complete an action.  Synonym for {@link action}.
@@ -2173,7 +2568,7 @@ class Machine {
  *  ```typescript
  *  import * as jssm from 'jssm';
  *
- *  const switch = jssm.from('on <=> off;');
+ *  const lswitch = jssm.from('on <=> off;');
  *  ```
  *
  *  @typeparam mDT The type of the machine data member; usually omitted
@@ -2208,7 +2603,7 @@ function sm(template_strings, ...remainder /* , arguments */) {
  *  ```typescript
  *  import * as jssm from 'jssm';
  *
- *  const switch = jssm.from('on <=> off;');
+ *  const lswitch = jssm.from('on <=> off;');
  *  ```
  *
  *  @typeparam mDT The type of the machine data member; usually omitted
@@ -2277,4 +2672,4 @@ function deserialize(machine_string, ser) {
 }
 export { version, transfer_state_properties, Machine, deserialize, make, wrap_parse as parse, compile, sm, from, arrow_direction, arrow_left_kind, arrow_right_kind, 
 // WHARGARBL TODO these should be exported to a utility library
-seq, unique, find_repeated, weighted_rand_select, histograph, weighted_sample_select, weighted_histo_key, constants, shapes, gviz_shapes, named_colors, is_hook_rejection, is_hook_complex_result, abstract_hook_step };
+seq, unique, find_repeated, weighted_rand_select, histograph, weighted_sample_select, weighted_histo_key, constants, shapes, gviz_shapes, named_colors, is_hook_rejection, is_hook_complex_result, abstract_hook_step, state_style_condense };

package/dist/es6/jssm_base_stylesheet.d.ts

@@ -0,0 +1,10 @@
+import { JssmStateConfig } from './jssm_types';
+declare const base_state_style: JssmStateConfig;
+declare const base_active_state_style: JssmStateConfig;
+declare const base_terminal_state_style: JssmStateConfig;
+declare const base_active_terminal_state_style: JssmStateConfig;
+declare const base_start_state_style: JssmStateConfig;
+declare const base_active_start_state_style: JssmStateConfig;
+declare const base_end_state_style: JssmStateConfig;
+declare const base_active_end_state_style: JssmStateConfig;
+export { base_state_style, base_active_state_style, base_terminal_state_style, base_active_terminal_state_style, base_start_state_style, base_active_start_state_style, base_end_state_style, base_active_end_state_style };